5 // These should be provided...somehow...
6 void *memset(void *s, int c, size_t n);
7 void *memcpy(void *dest, const void *src, size_t n);
8 int memcmp(const void *s1, const void *s2, size_t n);
10 extern void __attribute__((noreturn)) abort(void);
11 static inline void assert(bool expression) {
12 if (!expression) { abort(); }
15 uint32_t __attribute__((export_name("test_bigint_pass_deadbeef0badf00d"))) test_bigint_pass_deadbeef0badf00d(uint64_t val) {
16 return val == 0xdeadbeef0badf00dULL;
20 void *malloc(size_t size);
23 #define MALLOC(a, _) malloc(a)
24 #define do_MALLOC(a, _b, _c) malloc(a)
25 #define FREE(p) if ((unsigned long)(p) > 4096) { free(p); }
26 #define DO_ASSERT(a) (void)(a)
28 #define CHECK_ACCESS(p)
29 #define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
31 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
32 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
33 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
34 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
36 _Static_assert(sizeof(void*) == 4, "Pointers mut be 32 bits");
38 #define DECL_ARR_TYPE(ty, name) \
39 struct name##array { \
40 uint64_t arr_len; /* uint32_t would suffice but we want to align uint64_ts as well */ \
43 typedef struct name##array * name##Array; \
44 static inline name##Array init_##name##Array(size_t arr_len, int lineno) { \
45 name##Array arr = (name##Array)do_MALLOC(arr_len * sizeof(ty) + sizeof(uint64_t), #name" array init", lineno); \
46 arr->arr_len = arr_len; \
50 DECL_ARR_TYPE(int64_t, int64_t);
51 DECL_ARR_TYPE(uint64_t, uint64_t);
52 DECL_ARR_TYPE(int8_t, int8_t);
53 DECL_ARR_TYPE(int16_t, int16_t);
54 DECL_ARR_TYPE(uint32_t, uint32_t);
55 DECL_ARR_TYPE(void*, ptr);
56 DECL_ARR_TYPE(char, char);
57 typedef charArray jstring;
59 static inline jstring str_ref_to_ts(const char* chars, size_t len) {
60 charArray arr = init_charArray(len, __LINE__);
61 memcpy(arr->elems, chars, len);
64 static inline LDKStr str_ref_to_owned_c(const jstring str) {
65 char* newchars = MALLOC(str->arr_len + 1, "String chars");
66 memcpy(newchars, str->elems, str->arr_len);
67 newchars[str->arr_len] = 0;
71 .chars_is_owned = true
76 typedef bool jboolean;
78 uint32_t __attribute__((export_name("TS_malloc"))) TS_malloc(uint32_t size) {
79 return (uint32_t)MALLOC(size, "JS-Called malloc");
81 void __attribute__((export_name("TS_free"))) TS_free(uint32_t ptr) {
85 jstring __attribute__((export_name("TS_get_ldk_c_bindings_version"))) TS_get_ldk_c_bindings_version() {
86 const char *res = check_get_ldk_bindings_version();
87 if (res == NULL) return NULL;
88 return str_ref_to_ts(res, strlen(res));
90 jstring __attribute__((export_name("TS_get_ldk_version"))) get_ldk_version() {
91 const char *res = check_get_ldk_version();
92 if (res == NULL) return NULL;
93 return str_ref_to_ts(res, strlen(res));
96 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
98 static inline void* untag_ptr(uint64_t ptr) {
99 if (ptr < 4096) return (void*)ptr;
100 if (sizeof(void*) == 4) {
101 // For 32-bit systems, store pointers as 64-bit ints and use the 31st bit
102 return (void*)(uintptr_t)ptr;
104 // For 64-bit systems, assume the top byte is used for tagging, then
105 // use bit 9 ^ bit 10.
106 uint64_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
107 uintptr_t p = (ptr & ~(1ULL << 55)) | (tenth_bit << 55);
108 #ifdef LDK_DEBUG_BUILD
109 // On debug builds we also use the 11th bit as a debug flag
110 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
111 CHECK(tenth_bit != eleventh_bit);
117 static inline bool ptr_is_owned(uint64_t ptr) {
118 if(ptr < 4096) return true;
119 if (sizeof(void*) == 4) {
120 return ptr & (1ULL << 32);
122 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
123 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
124 #ifdef LDK_DEBUG_BUILD
125 // On debug builds we also use the 11th bit as a debug flag
126 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
127 CHECK(tenth_bit != eleventh_bit);
129 return (ninth_bit ^ tenth_bit) ? true : false;
132 static inline uint64_t tag_ptr(const void* ptr, bool is_owned) {
133 if ((uintptr_t)ptr < 4096) return (uint64_t)ptr;
134 if (sizeof(void*) == 4) {
135 return (((uint64_t)ptr) | ((is_owned ? 1ULL : 0) << 32));
137 CHECK(sizeof(uintptr_t) == 8);
138 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
139 uintptr_t t = (((uintptr_t)ptr) | (((is_owned ? 1ULL : 0ULL) ^ tenth_bit) << 55));
140 #ifdef LDK_DEBUG_BUILD
141 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
142 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
143 CHECK(ninth_bit == tenth_bit);
144 CHECK(ninth_bit == eleventh_bit);
147 CHECK(ptr_is_owned(t) == is_owned);
148 CHECK(untag_ptr(t) == ptr);
153 static inline LDKCOption_NoneZ LDKCOption_NoneZ_from_js(int32_t ord) {
155 case 0: return LDKCOption_NoneZ_Some;
156 case 1: return LDKCOption_NoneZ_None;
160 static inline int32_t LDKCOption_NoneZ_to_js(LDKCOption_NoneZ val) {
162 case LDKCOption_NoneZ_Some: return 0;
163 case LDKCOption_NoneZ_None: return 1;
167 static inline LDKChannelMonitorUpdateStatus LDKChannelMonitorUpdateStatus_from_js(int32_t ord) {
169 case 0: return LDKChannelMonitorUpdateStatus_Completed;
170 case 1: return LDKChannelMonitorUpdateStatus_InProgress;
171 case 2: return LDKChannelMonitorUpdateStatus_PermanentFailure;
175 static inline int32_t LDKChannelMonitorUpdateStatus_to_js(LDKChannelMonitorUpdateStatus val) {
177 case LDKChannelMonitorUpdateStatus_Completed: return 0;
178 case LDKChannelMonitorUpdateStatus_InProgress: return 1;
179 case LDKChannelMonitorUpdateStatus_PermanentFailure: return 2;
183 static inline LDKConfirmationTarget LDKConfirmationTarget_from_js(int32_t ord) {
185 case 0: return LDKConfirmationTarget_Background;
186 case 1: return LDKConfirmationTarget_Normal;
187 case 2: return LDKConfirmationTarget_HighPriority;
191 static inline int32_t LDKConfirmationTarget_to_js(LDKConfirmationTarget val) {
193 case LDKConfirmationTarget_Background: return 0;
194 case LDKConfirmationTarget_Normal: return 1;
195 case LDKConfirmationTarget_HighPriority: return 2;
199 static inline LDKCreationError LDKCreationError_from_js(int32_t ord) {
201 case 0: return LDKCreationError_DescriptionTooLong;
202 case 1: return LDKCreationError_RouteTooLong;
203 case 2: return LDKCreationError_TimestampOutOfBounds;
204 case 3: return LDKCreationError_InvalidAmount;
205 case 4: return LDKCreationError_MissingRouteHints;
206 case 5: return LDKCreationError_MinFinalCltvExpiryDeltaTooShort;
210 static inline int32_t LDKCreationError_to_js(LDKCreationError val) {
212 case LDKCreationError_DescriptionTooLong: return 0;
213 case LDKCreationError_RouteTooLong: return 1;
214 case LDKCreationError_TimestampOutOfBounds: return 2;
215 case LDKCreationError_InvalidAmount: return 3;
216 case LDKCreationError_MissingRouteHints: return 4;
217 case LDKCreationError_MinFinalCltvExpiryDeltaTooShort: return 5;
221 static inline LDKCurrency LDKCurrency_from_js(int32_t ord) {
223 case 0: return LDKCurrency_Bitcoin;
224 case 1: return LDKCurrency_BitcoinTestnet;
225 case 2: return LDKCurrency_Regtest;
226 case 3: return LDKCurrency_Simnet;
227 case 4: return LDKCurrency_Signet;
231 static inline int32_t LDKCurrency_to_js(LDKCurrency val) {
233 case LDKCurrency_Bitcoin: return 0;
234 case LDKCurrency_BitcoinTestnet: return 1;
235 case LDKCurrency_Regtest: return 2;
236 case LDKCurrency_Simnet: return 3;
237 case LDKCurrency_Signet: return 4;
241 static inline LDKFailureCode LDKFailureCode_from_js(int32_t ord) {
243 case 0: return LDKFailureCode_TemporaryNodeFailure;
244 case 1: return LDKFailureCode_RequiredNodeFeatureMissing;
245 case 2: return LDKFailureCode_IncorrectOrUnknownPaymentDetails;
249 static inline int32_t LDKFailureCode_to_js(LDKFailureCode val) {
251 case LDKFailureCode_TemporaryNodeFailure: return 0;
252 case LDKFailureCode_RequiredNodeFeatureMissing: return 1;
253 case LDKFailureCode_IncorrectOrUnknownPaymentDetails: return 2;
257 static inline LDKHTLCClaim LDKHTLCClaim_from_js(int32_t ord) {
259 case 0: return LDKHTLCClaim_OfferedTimeout;
260 case 1: return LDKHTLCClaim_OfferedPreimage;
261 case 2: return LDKHTLCClaim_AcceptedTimeout;
262 case 3: return LDKHTLCClaim_AcceptedPreimage;
263 case 4: return LDKHTLCClaim_Revocation;
267 static inline int32_t LDKHTLCClaim_to_js(LDKHTLCClaim val) {
269 case LDKHTLCClaim_OfferedTimeout: return 0;
270 case LDKHTLCClaim_OfferedPreimage: return 1;
271 case LDKHTLCClaim_AcceptedTimeout: return 2;
272 case LDKHTLCClaim_AcceptedPreimage: return 3;
273 case LDKHTLCClaim_Revocation: return 4;
277 static inline LDKIOError LDKIOError_from_js(int32_t ord) {
279 case 0: return LDKIOError_NotFound;
280 case 1: return LDKIOError_PermissionDenied;
281 case 2: return LDKIOError_ConnectionRefused;
282 case 3: return LDKIOError_ConnectionReset;
283 case 4: return LDKIOError_ConnectionAborted;
284 case 5: return LDKIOError_NotConnected;
285 case 6: return LDKIOError_AddrInUse;
286 case 7: return LDKIOError_AddrNotAvailable;
287 case 8: return LDKIOError_BrokenPipe;
288 case 9: return LDKIOError_AlreadyExists;
289 case 10: return LDKIOError_WouldBlock;
290 case 11: return LDKIOError_InvalidInput;
291 case 12: return LDKIOError_InvalidData;
292 case 13: return LDKIOError_TimedOut;
293 case 14: return LDKIOError_WriteZero;
294 case 15: return LDKIOError_Interrupted;
295 case 16: return LDKIOError_Other;
296 case 17: return LDKIOError_UnexpectedEof;
300 static inline int32_t LDKIOError_to_js(LDKIOError val) {
302 case LDKIOError_NotFound: return 0;
303 case LDKIOError_PermissionDenied: return 1;
304 case LDKIOError_ConnectionRefused: return 2;
305 case LDKIOError_ConnectionReset: return 3;
306 case LDKIOError_ConnectionAborted: return 4;
307 case LDKIOError_NotConnected: return 5;
308 case LDKIOError_AddrInUse: return 6;
309 case LDKIOError_AddrNotAvailable: return 7;
310 case LDKIOError_BrokenPipe: return 8;
311 case LDKIOError_AlreadyExists: return 9;
312 case LDKIOError_WouldBlock: return 10;
313 case LDKIOError_InvalidInput: return 11;
314 case LDKIOError_InvalidData: return 12;
315 case LDKIOError_TimedOut: return 13;
316 case LDKIOError_WriteZero: return 14;
317 case LDKIOError_Interrupted: return 15;
318 case LDKIOError_Other: return 16;
319 case LDKIOError_UnexpectedEof: return 17;
323 static inline LDKLevel LDKLevel_from_js(int32_t ord) {
325 case 0: return LDKLevel_Gossip;
326 case 1: return LDKLevel_Trace;
327 case 2: return LDKLevel_Debug;
328 case 3: return LDKLevel_Info;
329 case 4: return LDKLevel_Warn;
330 case 5: return LDKLevel_Error;
334 static inline int32_t LDKLevel_to_js(LDKLevel val) {
336 case LDKLevel_Gossip: return 0;
337 case LDKLevel_Trace: return 1;
338 case LDKLevel_Debug: return 2;
339 case LDKLevel_Info: return 3;
340 case LDKLevel_Warn: return 4;
341 case LDKLevel_Error: return 5;
345 static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
347 case 0: return LDKNetwork_Bitcoin;
348 case 1: return LDKNetwork_Testnet;
349 case 2: return LDKNetwork_Regtest;
350 case 3: return LDKNetwork_Signet;
354 static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
356 case LDKNetwork_Bitcoin: return 0;
357 case LDKNetwork_Testnet: return 1;
358 case LDKNetwork_Regtest: return 2;
359 case LDKNetwork_Signet: return 3;
363 static inline LDKPaymentFailureReason LDKPaymentFailureReason_from_js(int32_t ord) {
365 case 0: return LDKPaymentFailureReason_RecipientRejected;
366 case 1: return LDKPaymentFailureReason_UserAbandoned;
367 case 2: return LDKPaymentFailureReason_RetriesExhausted;
368 case 3: return LDKPaymentFailureReason_PaymentExpired;
369 case 4: return LDKPaymentFailureReason_RouteNotFound;
370 case 5: return LDKPaymentFailureReason_UnexpectedError;
374 static inline int32_t LDKPaymentFailureReason_to_js(LDKPaymentFailureReason val) {
376 case LDKPaymentFailureReason_RecipientRejected: return 0;
377 case LDKPaymentFailureReason_UserAbandoned: return 1;
378 case LDKPaymentFailureReason_RetriesExhausted: return 2;
379 case LDKPaymentFailureReason_PaymentExpired: return 3;
380 case LDKPaymentFailureReason_RouteNotFound: return 4;
381 case LDKPaymentFailureReason_UnexpectedError: return 5;
385 static inline LDKRecipient LDKRecipient_from_js(int32_t ord) {
387 case 0: return LDKRecipient_Node;
388 case 1: return LDKRecipient_PhantomNode;
392 static inline int32_t LDKRecipient_to_js(LDKRecipient val) {
394 case LDKRecipient_Node: return 0;
395 case LDKRecipient_PhantomNode: return 1;
399 static inline LDKRetryableSendFailure LDKRetryableSendFailure_from_js(int32_t ord) {
401 case 0: return LDKRetryableSendFailure_PaymentExpired;
402 case 1: return LDKRetryableSendFailure_RouteNotFound;
403 case 2: return LDKRetryableSendFailure_DuplicatePayment;
407 static inline int32_t LDKRetryableSendFailure_to_js(LDKRetryableSendFailure val) {
409 case LDKRetryableSendFailure_PaymentExpired: return 0;
410 case LDKRetryableSendFailure_RouteNotFound: return 1;
411 case LDKRetryableSendFailure_DuplicatePayment: return 2;
415 static inline LDKSecp256k1Error LDKSecp256k1Error_from_js(int32_t ord) {
417 case 0: return LDKSecp256k1Error_IncorrectSignature;
418 case 1: return LDKSecp256k1Error_InvalidMessage;
419 case 2: return LDKSecp256k1Error_InvalidPublicKey;
420 case 3: return LDKSecp256k1Error_InvalidSignature;
421 case 4: return LDKSecp256k1Error_InvalidSecretKey;
422 case 5: return LDKSecp256k1Error_InvalidSharedSecret;
423 case 6: return LDKSecp256k1Error_InvalidRecoveryId;
424 case 7: return LDKSecp256k1Error_InvalidTweak;
425 case 8: return LDKSecp256k1Error_NotEnoughMemory;
426 case 9: return LDKSecp256k1Error_InvalidPublicKeySum;
427 case 10: return LDKSecp256k1Error_InvalidParityValue;
431 static inline int32_t LDKSecp256k1Error_to_js(LDKSecp256k1Error val) {
433 case LDKSecp256k1Error_IncorrectSignature: return 0;
434 case LDKSecp256k1Error_InvalidMessage: return 1;
435 case LDKSecp256k1Error_InvalidPublicKey: return 2;
436 case LDKSecp256k1Error_InvalidSignature: return 3;
437 case LDKSecp256k1Error_InvalidSecretKey: return 4;
438 case LDKSecp256k1Error_InvalidSharedSecret: return 5;
439 case LDKSecp256k1Error_InvalidRecoveryId: return 6;
440 case LDKSecp256k1Error_InvalidTweak: return 7;
441 case LDKSecp256k1Error_NotEnoughMemory: return 8;
442 case LDKSecp256k1Error_InvalidPublicKeySum: return 9;
443 case LDKSecp256k1Error_InvalidParityValue: return 10;
447 static inline LDKSemanticError LDKSemanticError_from_js(int32_t ord) {
449 case 0: return LDKSemanticError_NoPaymentHash;
450 case 1: return LDKSemanticError_MultiplePaymentHashes;
451 case 2: return LDKSemanticError_NoDescription;
452 case 3: return LDKSemanticError_MultipleDescriptions;
453 case 4: return LDKSemanticError_NoPaymentSecret;
454 case 5: return LDKSemanticError_MultiplePaymentSecrets;
455 case 6: return LDKSemanticError_InvalidFeatures;
456 case 7: return LDKSemanticError_InvalidRecoveryId;
457 case 8: return LDKSemanticError_InvalidSignature;
458 case 9: return LDKSemanticError_ImpreciseAmount;
462 static inline int32_t LDKSemanticError_to_js(LDKSemanticError val) {
464 case LDKSemanticError_NoPaymentHash: return 0;
465 case LDKSemanticError_MultiplePaymentHashes: return 1;
466 case LDKSemanticError_NoDescription: return 2;
467 case LDKSemanticError_MultipleDescriptions: return 3;
468 case LDKSemanticError_NoPaymentSecret: return 4;
469 case LDKSemanticError_MultiplePaymentSecrets: return 5;
470 case LDKSemanticError_InvalidFeatures: return 6;
471 case LDKSemanticError_InvalidRecoveryId: return 7;
472 case LDKSemanticError_InvalidSignature: return 8;
473 case LDKSemanticError_ImpreciseAmount: return 9;
477 static inline LDKSiPrefix LDKSiPrefix_from_js(int32_t ord) {
479 case 0: return LDKSiPrefix_Milli;
480 case 1: return LDKSiPrefix_Micro;
481 case 2: return LDKSiPrefix_Nano;
482 case 3: return LDKSiPrefix_Pico;
486 static inline int32_t LDKSiPrefix_to_js(LDKSiPrefix val) {
488 case LDKSiPrefix_Milli: return 0;
489 case LDKSiPrefix_Micro: return 1;
490 case LDKSiPrefix_Nano: return 2;
491 case LDKSiPrefix_Pico: return 3;
495 static inline LDKUtxoLookupError LDKUtxoLookupError_from_js(int32_t ord) {
497 case 0: return LDKUtxoLookupError_UnknownChain;
498 case 1: return LDKUtxoLookupError_UnknownTx;
502 static inline int32_t LDKUtxoLookupError_to_js(LDKUtxoLookupError val) {
504 case LDKUtxoLookupError_UnknownChain: return 0;
505 case LDKUtxoLookupError_UnknownTx: return 1;
509 struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing) {
510 LDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };
513 int8_tArray __attribute__((export_name("TS_BigEndianScalar_get_bytes"))) TS_BigEndianScalar_get_bytes(uint64_t thing) {
514 LDKBigEndianScalar* thing_conv = (LDKBigEndianScalar*)untag_ptr(thing);
515 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
516 memcpy(ret_arr->elems, BigEndianScalar_get_bytes(thing_conv).data, 32);
520 static void BigEndianScalar_free (struct LDKBigEndianScalar thing) {}
521 void __attribute__((export_name("TS_BigEndianScalar_free"))) TS_BigEndianScalar_free(uint64_t thing) {
522 if (!ptr_is_owned(thing)) return;
523 void* thing_ptr = untag_ptr(thing);
524 CHECK_ACCESS(thing_ptr);
525 LDKBigEndianScalar thing_conv = *(LDKBigEndianScalar*)(thing_ptr);
526 FREE(untag_ptr(thing));
527 BigEndianScalar_free(thing_conv);
530 uint32_t __attribute__((export_name("TS_LDKBech32Error_ty_from_ptr"))) TS_LDKBech32Error_ty_from_ptr(uint64_t ptr) {
531 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
533 case LDKBech32Error_MissingSeparator: return 0;
534 case LDKBech32Error_InvalidChecksum: return 1;
535 case LDKBech32Error_InvalidLength: return 2;
536 case LDKBech32Error_InvalidChar: return 3;
537 case LDKBech32Error_InvalidData: return 4;
538 case LDKBech32Error_InvalidPadding: return 5;
539 case LDKBech32Error_MixedCase: return 6;
543 int32_t __attribute__((export_name("TS_LDKBech32Error_InvalidChar_get_invalid_char"))) TS_LDKBech32Error_InvalidChar_get_invalid_char(uint64_t ptr) {
544 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
545 assert(obj->tag == LDKBech32Error_InvalidChar);
546 int32_t invalid_char_conv = obj->invalid_char;
547 return invalid_char_conv;
549 int8_t __attribute__((export_name("TS_LDKBech32Error_InvalidData_get_invalid_data"))) TS_LDKBech32Error_InvalidData_get_invalid_data(uint64_t ptr) {
550 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
551 assert(obj->tag == LDKBech32Error_InvalidData);
552 int8_t invalid_data_conv = obj->invalid_data;
553 return invalid_data_conv;
555 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
556 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
557 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
560 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) {
561 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
562 LDKCVec_u8Z ret_var = TxOut_get_script_pubkey(thing_conv);
563 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
564 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
565 CVec_u8Z_free(ret_var);
569 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) {
570 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
571 int64_t ret_conv = TxOut_get_value(thing_conv);
575 uint32_t __attribute__((export_name("TS_LDKCOption_DurationZ_ty_from_ptr"))) TS_LDKCOption_DurationZ_ty_from_ptr(uint64_t ptr) {
576 LDKCOption_DurationZ *obj = (LDKCOption_DurationZ*)untag_ptr(ptr);
578 case LDKCOption_DurationZ_Some: return 0;
579 case LDKCOption_DurationZ_None: return 1;
583 int64_t __attribute__((export_name("TS_LDKCOption_DurationZ_Some_get_some"))) TS_LDKCOption_DurationZ_Some_get_some(uint64_t ptr) {
584 LDKCOption_DurationZ *obj = (LDKCOption_DurationZ*)untag_ptr(ptr);
585 assert(obj->tag == LDKCOption_DurationZ_Some);
586 int64_t some_conv = obj->some;
589 static inline LDKCVec_BlindedPathZ CVec_BlindedPathZ_clone(const LDKCVec_BlindedPathZ *orig) {
590 LDKCVec_BlindedPathZ ret = { .data = MALLOC(sizeof(LDKBlindedPath) * orig->datalen, "LDKCVec_BlindedPathZ clone bytes"), .datalen = orig->datalen };
591 for (size_t i = 0; i < ret.datalen; i++) {
592 ret.data[i] = BlindedPath_clone(&orig->data[i]);
596 uint32_t __attribute__((export_name("TS_LDKCOption_u64Z_ty_from_ptr"))) TS_LDKCOption_u64Z_ty_from_ptr(uint64_t ptr) {
597 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
599 case LDKCOption_u64Z_Some: return 0;
600 case LDKCOption_u64Z_None: return 1;
604 int64_t __attribute__((export_name("TS_LDKCOption_u64Z_Some_get_some"))) TS_LDKCOption_u64Z_Some_get_some(uint64_t ptr) {
605 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
606 assert(obj->tag == LDKCOption_u64Z_Some);
607 int64_t some_conv = obj->some;
610 uint32_t __attribute__((export_name("TS_LDKAPIError_ty_from_ptr"))) TS_LDKAPIError_ty_from_ptr(uint64_t ptr) {
611 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
613 case LDKAPIError_APIMisuseError: return 0;
614 case LDKAPIError_FeeRateTooHigh: return 1;
615 case LDKAPIError_InvalidRoute: return 2;
616 case LDKAPIError_ChannelUnavailable: return 3;
617 case LDKAPIError_MonitorUpdateInProgress: return 4;
618 case LDKAPIError_IncompatibleShutdownScript: return 5;
622 jstring __attribute__((export_name("TS_LDKAPIError_APIMisuseError_get_err"))) TS_LDKAPIError_APIMisuseError_get_err(uint64_t ptr) {
623 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
624 assert(obj->tag == LDKAPIError_APIMisuseError);
625 LDKStr err_str = obj->api_misuse_error.err;
626 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
629 jstring __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_err"))) TS_LDKAPIError_FeeRateTooHigh_get_err(uint64_t ptr) {
630 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
631 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
632 LDKStr err_str = obj->fee_rate_too_high.err;
633 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
636 int32_t __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_feerate"))) TS_LDKAPIError_FeeRateTooHigh_get_feerate(uint64_t ptr) {
637 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
638 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
639 int32_t feerate_conv = obj->fee_rate_too_high.feerate;
642 jstring __attribute__((export_name("TS_LDKAPIError_InvalidRoute_get_err"))) TS_LDKAPIError_InvalidRoute_get_err(uint64_t ptr) {
643 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
644 assert(obj->tag == LDKAPIError_InvalidRoute);
645 LDKStr err_str = obj->invalid_route.err;
646 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
649 jstring __attribute__((export_name("TS_LDKAPIError_ChannelUnavailable_get_err"))) TS_LDKAPIError_ChannelUnavailable_get_err(uint64_t ptr) {
650 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
651 assert(obj->tag == LDKAPIError_ChannelUnavailable);
652 LDKStr err_str = obj->channel_unavailable.err;
653 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
656 uint64_t __attribute__((export_name("TS_LDKAPIError_IncompatibleShutdownScript_get_script"))) TS_LDKAPIError_IncompatibleShutdownScript_get_script(uint64_t ptr) {
657 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
658 assert(obj->tag == LDKAPIError_IncompatibleShutdownScript);
659 LDKShutdownScript script_var = obj->incompatible_shutdown_script.script;
660 uint64_t script_ref = 0;
661 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
662 script_ref = tag_ptr(script_var.inner, false);
665 static inline void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
666 CHECK(owner->result_ok);
667 return *owner->contents.result;
669 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_ok"))) TS_CResult_NoneAPIErrorZ_get_ok(uint64_t owner) {
670 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
671 CResult_NoneAPIErrorZ_get_ok(owner_conv);
674 static inline struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
675 CHECK(!owner->result_ok);
676 return APIError_clone(&*owner->contents.err);
678 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_err"))) TS_CResult_NoneAPIErrorZ_get_err(uint64_t owner) {
679 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
680 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
681 *ret_copy = CResult_NoneAPIErrorZ_get_err(owner_conv);
682 uint64_t ret_ref = tag_ptr(ret_copy, true);
686 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
687 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
688 for (size_t i = 0; i < ret.datalen; i++) {
689 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
693 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
694 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
695 for (size_t i = 0; i < ret.datalen; i++) {
696 ret.data[i] = APIError_clone(&orig->data[i]);
700 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_u8ZZ_ty_from_ptr"))) TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(uint64_t ptr) {
701 LDKCOption_CVec_u8ZZ *obj = (LDKCOption_CVec_u8ZZ*)untag_ptr(ptr);
703 case LDKCOption_CVec_u8ZZ_Some: return 0;
704 case LDKCOption_CVec_u8ZZ_None: return 1;
708 int8_tArray __attribute__((export_name("TS_LDKCOption_CVec_u8ZZ_Some_get_some"))) TS_LDKCOption_CVec_u8ZZ_Some_get_some(uint64_t ptr) {
709 LDKCOption_CVec_u8ZZ *obj = (LDKCOption_CVec_u8ZZ*)untag_ptr(ptr);
710 assert(obj->tag == LDKCOption_CVec_u8ZZ_Some);
711 LDKCVec_u8Z some_var = obj->some;
712 int8_tArray some_arr = init_int8_tArray(some_var.datalen, __LINE__);
713 memcpy(some_arr->elems, some_var.data, some_var.datalen);
716 uint32_t __attribute__((export_name("TS_LDKDecodeError_ty_from_ptr"))) TS_LDKDecodeError_ty_from_ptr(uint64_t ptr) {
717 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
719 case LDKDecodeError_UnknownVersion: return 0;
720 case LDKDecodeError_UnknownRequiredFeature: return 1;
721 case LDKDecodeError_InvalidValue: return 2;
722 case LDKDecodeError_ShortRead: return 3;
723 case LDKDecodeError_BadLengthDescriptor: return 4;
724 case LDKDecodeError_Io: return 5;
725 case LDKDecodeError_UnsupportedCompression: return 6;
729 uint32_t __attribute__((export_name("TS_LDKDecodeError_Io_get_io"))) TS_LDKDecodeError_Io_get_io(uint64_t ptr) {
730 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
731 assert(obj->tag == LDKDecodeError_Io);
732 uint32_t io_conv = LDKIOError_to_js(obj->io);
735 static inline struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner){
736 LDKRecipientOnionFields ret = *owner->contents.result;
737 ret.is_owned = false;
740 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(uint64_t owner) {
741 LDKCResult_RecipientOnionFieldsDecodeErrorZ* owner_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(owner);
742 LDKRecipientOnionFields ret_var = CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner_conv);
743 uint64_t ret_ref = 0;
744 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
745 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
749 static inline struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner){
750 CHECK(!owner->result_ok);
751 return DecodeError_clone(&*owner->contents.err);
753 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(uint64_t owner) {
754 LDKCResult_RecipientOnionFieldsDecodeErrorZ* owner_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(owner);
755 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
756 *ret_copy = CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner_conv);
757 uint64_t ret_ref = tag_ptr(ret_copy, true);
761 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_ty_from_ptr"))) TS_LDKCOption_HTLCClaimZ_ty_from_ptr(uint64_t ptr) {
762 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
764 case LDKCOption_HTLCClaimZ_Some: return 0;
765 case LDKCOption_HTLCClaimZ_None: return 1;
769 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_Some_get_some"))) TS_LDKCOption_HTLCClaimZ_Some_get_some(uint64_t ptr) {
770 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
771 assert(obj->tag == LDKCOption_HTLCClaimZ_Some);
772 uint32_t some_conv = LDKHTLCClaim_to_js(obj->some);
775 static inline void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
776 CHECK(owner->result_ok);
777 return *owner->contents.result;
779 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_ok"))) TS_CResult_NoneNoneZ_get_ok(uint64_t owner) {
780 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
781 CResult_NoneNoneZ_get_ok(owner_conv);
784 static inline void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
785 CHECK(!owner->result_ok);
786 return *owner->contents.err;
788 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_err"))) TS_CResult_NoneNoneZ_get_err(uint64_t owner) {
789 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
790 CResult_NoneNoneZ_get_err(owner_conv);
793 static inline struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
794 LDKCounterpartyCommitmentSecrets ret = *owner->contents.result;
795 ret.is_owned = false;
798 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(uint64_t owner) {
799 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
800 LDKCounterpartyCommitmentSecrets ret_var = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_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 struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
808 CHECK(!owner->result_ok);
809 return DecodeError_clone(&*owner->contents.err);
811 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(uint64_t owner) {
812 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
813 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
814 *ret_copy = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner_conv);
815 uint64_t ret_ref = tag_ptr(ret_copy, true);
819 static inline struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
820 LDKTxCreationKeys ret = *owner->contents.result;
821 ret.is_owned = false;
824 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(uint64_t owner) {
825 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
826 LDKTxCreationKeys ret_var = CResult_TxCreationKeysDecodeErrorZ_get_ok(owner_conv);
827 uint64_t ret_ref = 0;
828 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
829 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
833 static inline struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
834 CHECK(!owner->result_ok);
835 return DecodeError_clone(&*owner->contents.err);
837 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_err(uint64_t owner) {
838 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
839 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
840 *ret_copy = CResult_TxCreationKeysDecodeErrorZ_get_err(owner_conv);
841 uint64_t ret_ref = tag_ptr(ret_copy, true);
845 static inline struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
846 LDKChannelPublicKeys ret = *owner->contents.result;
847 ret.is_owned = false;
850 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint64_t owner) {
851 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
852 LDKChannelPublicKeys ret_var = CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner_conv);
853 uint64_t ret_ref = 0;
854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
855 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
859 static inline struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
860 CHECK(!owner->result_ok);
861 return DecodeError_clone(&*owner->contents.err);
863 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(uint64_t owner) {
864 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
865 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
866 *ret_copy = CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner_conv);
867 uint64_t ret_ref = tag_ptr(ret_copy, true);
871 uint32_t __attribute__((export_name("TS_LDKCOption_u32Z_ty_from_ptr"))) TS_LDKCOption_u32Z_ty_from_ptr(uint64_t ptr) {
872 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
874 case LDKCOption_u32Z_Some: return 0;
875 case LDKCOption_u32Z_None: return 1;
879 int32_t __attribute__((export_name("TS_LDKCOption_u32Z_Some_get_some"))) TS_LDKCOption_u32Z_Some_get_some(uint64_t ptr) {
880 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
881 assert(obj->tag == LDKCOption_u32Z_Some);
882 int32_t some_conv = obj->some;
885 static inline struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
886 LDKHTLCOutputInCommitment ret = *owner->contents.result;
887 ret.is_owned = false;
890 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint64_t owner) {
891 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
892 LDKHTLCOutputInCommitment ret_var = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner_conv);
893 uint64_t ret_ref = 0;
894 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
895 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
899 static inline struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
900 CHECK(!owner->result_ok);
901 return DecodeError_clone(&*owner->contents.err);
903 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(uint64_t owner) {
904 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
905 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
906 *ret_copy = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner_conv);
907 uint64_t ret_ref = tag_ptr(ret_copy, true);
911 static inline struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
912 LDKCounterpartyChannelTransactionParameters ret = *owner->contents.result;
913 ret.is_owned = false;
916 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
917 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
918 LDKCounterpartyChannelTransactionParameters ret_var = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
919 uint64_t ret_ref = 0;
920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
921 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
925 static inline struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
926 CHECK(!owner->result_ok);
927 return DecodeError_clone(&*owner->contents.err);
929 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
930 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
931 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
932 *ret_copy = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
933 uint64_t ret_ref = tag_ptr(ret_copy, true);
937 static inline struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
938 LDKChannelTransactionParameters ret = *owner->contents.result;
939 ret.is_owned = false;
942 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
943 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
944 LDKChannelTransactionParameters ret_var = CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
945 uint64_t ret_ref = 0;
946 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
947 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
951 static inline struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
952 CHECK(!owner->result_ok);
953 return DecodeError_clone(&*owner->contents.err);
955 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
956 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
957 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
958 *ret_copy = CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
959 uint64_t ret_ref = tag_ptr(ret_copy, true);
963 static inline struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
964 LDKHolderCommitmentTransaction ret = *owner->contents.result;
965 ret.is_owned = false;
968 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
969 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
970 LDKHolderCommitmentTransaction ret_var = CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
971 uint64_t ret_ref = 0;
972 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
973 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
977 static inline struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
978 CHECK(!owner->result_ok);
979 return DecodeError_clone(&*owner->contents.err);
981 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
982 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
983 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
984 *ret_copy = CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
985 uint64_t ret_ref = tag_ptr(ret_copy, true);
989 static inline struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
990 LDKBuiltCommitmentTransaction ret = *owner->contents.result;
991 ret.is_owned = false;
994 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
995 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
996 LDKBuiltCommitmentTransaction ret_var = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
997 uint64_t ret_ref = 0;
998 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
999 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1003 static inline struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
1004 CHECK(!owner->result_ok);
1005 return DecodeError_clone(&*owner->contents.err);
1007 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
1008 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
1009 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1010 *ret_copy = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
1011 uint64_t ret_ref = tag_ptr(ret_copy, true);
1015 static inline struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
1016 LDKTrustedClosingTransaction ret = *owner->contents.result;
1017 ret.is_owned = false;
1020 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_get_ok(uint64_t owner) {
1021 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
1022 LDKTrustedClosingTransaction ret_var = CResult_TrustedClosingTransactionNoneZ_get_ok(owner_conv);
1023 uint64_t ret_ref = 0;
1024 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1025 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1029 static inline void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
1030 CHECK(!owner->result_ok);
1031 return *owner->contents.err;
1033 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_err"))) TS_CResult_TrustedClosingTransactionNoneZ_get_err(uint64_t owner) {
1034 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
1035 CResult_TrustedClosingTransactionNoneZ_get_err(owner_conv);
1038 static inline struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
1039 LDKCommitmentTransaction ret = *owner->contents.result;
1040 ret.is_owned = false;
1043 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
1044 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
1045 LDKCommitmentTransaction ret_var = CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
1046 uint64_t ret_ref = 0;
1047 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1048 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1052 static inline struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
1053 CHECK(!owner->result_ok);
1054 return DecodeError_clone(&*owner->contents.err);
1056 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
1057 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
1058 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1059 *ret_copy = CResult_CommitmentTransactionDecodeErrorZ_get_err(owner_conv);
1060 uint64_t ret_ref = tag_ptr(ret_copy, true);
1064 static inline struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
1065 LDKTrustedCommitmentTransaction ret = *owner->contents.result;
1066 ret.is_owned = false;
1069 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(uint64_t owner) {
1070 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
1071 LDKTrustedCommitmentTransaction ret_var = CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner_conv);
1072 uint64_t ret_ref = 0;
1073 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1074 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1078 static inline void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
1079 CHECK(!owner->result_ok);
1080 return *owner->contents.err;
1082 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(uint64_t owner) {
1083 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
1084 CResult_TrustedCommitmentTransactionNoneZ_get_err(owner_conv);
1087 static inline struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
1088 CHECK(owner->result_ok);
1089 return *owner->contents.result;
1091 ptrArray __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_ok"))) TS_CResult_CVec_SignatureZNoneZ_get_ok(uint64_t owner) {
1092 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(owner);
1093 LDKCVec_SignatureZ ret_var = CResult_CVec_SignatureZNoneZ_get_ok(owner_conv);
1094 ptrArray ret_arr = NULL;
1095 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
1096 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
1097 for (size_t m = 0; m < ret_var.datalen; m++) {
1098 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
1099 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
1100 ret_arr_ptr[m] = ret_conv_12_arr;
1106 static inline void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
1107 CHECK(!owner->result_ok);
1108 return *owner->contents.err;
1110 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_err"))) TS_CResult_CVec_SignatureZNoneZ_get_err(uint64_t owner) {
1111 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(owner);
1112 CResult_CVec_SignatureZNoneZ_get_err(owner_conv);
1115 static inline struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
1116 LDKShutdownScript ret = *owner->contents.result;
1117 ret.is_owned = false;
1120 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(uint64_t owner) {
1121 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
1122 LDKShutdownScript ret_var = CResult_ShutdownScriptDecodeErrorZ_get_ok(owner_conv);
1123 uint64_t ret_ref = 0;
1124 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1125 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1129 static inline struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
1130 CHECK(!owner->result_ok);
1131 return DecodeError_clone(&*owner->contents.err);
1133 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_err(uint64_t owner) {
1134 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
1135 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1136 *ret_copy = CResult_ShutdownScriptDecodeErrorZ_get_err(owner_conv);
1137 uint64_t ret_ref = tag_ptr(ret_copy, true);
1141 static inline struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
1142 LDKShutdownScript ret = *owner->contents.result;
1143 ret.is_owned = false;
1146 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint64_t owner) {
1147 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
1148 LDKShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner_conv);
1149 uint64_t ret_ref = 0;
1150 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1151 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1155 static inline struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
1156 LDKInvalidShutdownScript ret = *owner->contents.err;
1157 ret.is_owned = false;
1160 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(uint64_t owner) {
1161 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
1162 LDKInvalidShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner_conv);
1163 uint64_t ret_ref = 0;
1164 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1165 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1169 static inline struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner){
1170 LDKBlindedPayInfo ret = *owner->contents.result;
1171 ret.is_owned = false;
1174 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(uint64_t owner) {
1175 LDKCResult_BlindedPayInfoDecodeErrorZ* owner_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(owner);
1176 LDKBlindedPayInfo ret_var = CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner_conv);
1177 uint64_t ret_ref = 0;
1178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1179 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1183 static inline struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner){
1184 CHECK(!owner->result_ok);
1185 return DecodeError_clone(&*owner->contents.err);
1187 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_get_err"))) TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(uint64_t owner) {
1188 LDKCResult_BlindedPayInfoDecodeErrorZ* owner_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(owner);
1189 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1190 *ret_copy = CResult_BlindedPayInfoDecodeErrorZ_get_err(owner_conv);
1191 uint64_t ret_ref = tag_ptr(ret_copy, true);
1195 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
1196 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
1197 for (size_t i = 0; i < ret.datalen; i++) {
1198 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
1202 static inline struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1203 LDKRoute ret = *owner->contents.result;
1204 ret.is_owned = false;
1207 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_ok"))) TS_CResult_RouteLightningErrorZ_get_ok(uint64_t owner) {
1208 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
1209 LDKRoute ret_var = CResult_RouteLightningErrorZ_get_ok(owner_conv);
1210 uint64_t ret_ref = 0;
1211 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1212 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1216 static inline struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1217 LDKLightningError ret = *owner->contents.err;
1218 ret.is_owned = false;
1221 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_err"))) TS_CResult_RouteLightningErrorZ_get_err(uint64_t owner) {
1222 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
1223 LDKLightningError ret_var = CResult_RouteLightningErrorZ_get_err(owner_conv);
1224 uint64_t ret_ref = 0;
1225 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1226 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1230 static inline struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
1231 LDKInFlightHtlcs ret = *owner->contents.result;
1232 ret.is_owned = false;
1235 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(uint64_t owner) {
1236 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
1237 LDKInFlightHtlcs ret_var = CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner_conv);
1238 uint64_t ret_ref = 0;
1239 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1240 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1244 static inline struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
1245 CHECK(!owner->result_ok);
1246 return DecodeError_clone(&*owner->contents.err);
1248 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(uint64_t owner) {
1249 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
1250 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1251 *ret_copy = CResult_InFlightHtlcsDecodeErrorZ_get_err(owner_conv);
1252 uint64_t ret_ref = tag_ptr(ret_copy, true);
1256 static inline struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1257 LDKRouteHop ret = *owner->contents.result;
1258 ret.is_owned = false;
1261 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHopDecodeErrorZ_get_ok(uint64_t owner) {
1262 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
1263 LDKRouteHop ret_var = CResult_RouteHopDecodeErrorZ_get_ok(owner_conv);
1264 uint64_t ret_ref = 0;
1265 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1266 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1270 static inline struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1271 CHECK(!owner->result_ok);
1272 return DecodeError_clone(&*owner->contents.err);
1274 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_err"))) TS_CResult_RouteHopDecodeErrorZ_get_err(uint64_t owner) {
1275 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
1276 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1277 *ret_copy = CResult_RouteHopDecodeErrorZ_get_err(owner_conv);
1278 uint64_t ret_ref = tag_ptr(ret_copy, true);
1282 static inline LDKCVec_BlindedHopZ CVec_BlindedHopZ_clone(const LDKCVec_BlindedHopZ *orig) {
1283 LDKCVec_BlindedHopZ ret = { .data = MALLOC(sizeof(LDKBlindedHop) * orig->datalen, "LDKCVec_BlindedHopZ clone bytes"), .datalen = orig->datalen };
1284 for (size_t i = 0; i < ret.datalen; i++) {
1285 ret.data[i] = BlindedHop_clone(&orig->data[i]);
1289 static inline struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner){
1290 LDKBlindedTail ret = *owner->contents.result;
1291 ret.is_owned = false;
1294 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_get_ok"))) TS_CResult_BlindedTailDecodeErrorZ_get_ok(uint64_t owner) {
1295 LDKCResult_BlindedTailDecodeErrorZ* owner_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(owner);
1296 LDKBlindedTail ret_var = CResult_BlindedTailDecodeErrorZ_get_ok(owner_conv);
1297 uint64_t ret_ref = 0;
1298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1303 static inline struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner){
1304 CHECK(!owner->result_ok);
1305 return DecodeError_clone(&*owner->contents.err);
1307 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_get_err"))) TS_CResult_BlindedTailDecodeErrorZ_get_err(uint64_t owner) {
1308 LDKCResult_BlindedTailDecodeErrorZ* owner_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(owner);
1309 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1310 *ret_copy = CResult_BlindedTailDecodeErrorZ_get_err(owner_conv);
1311 uint64_t ret_ref = tag_ptr(ret_copy, true);
1315 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
1316 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
1317 for (size_t i = 0; i < ret.datalen; i++) {
1318 ret.data[i] = RouteHop_clone(&orig->data[i]);
1322 static inline LDKCVec_PathZ CVec_PathZ_clone(const LDKCVec_PathZ *orig) {
1323 LDKCVec_PathZ ret = { .data = MALLOC(sizeof(LDKPath) * orig->datalen, "LDKCVec_PathZ clone bytes"), .datalen = orig->datalen };
1324 for (size_t i = 0; i < ret.datalen; i++) {
1325 ret.data[i] = Path_clone(&orig->data[i]);
1329 static inline struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1330 LDKRoute ret = *owner->contents.result;
1331 ret.is_owned = false;
1334 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_ok"))) TS_CResult_RouteDecodeErrorZ_get_ok(uint64_t owner) {
1335 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
1336 LDKRoute ret_var = CResult_RouteDecodeErrorZ_get_ok(owner_conv);
1337 uint64_t ret_ref = 0;
1338 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1339 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1343 static inline struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1344 CHECK(!owner->result_ok);
1345 return DecodeError_clone(&*owner->contents.err);
1347 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_err"))) TS_CResult_RouteDecodeErrorZ_get_err(uint64_t owner) {
1348 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
1349 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1350 *ret_copy = CResult_RouteDecodeErrorZ_get_err(owner_conv);
1351 uint64_t ret_ref = tag_ptr(ret_copy, true);
1355 static inline struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1356 LDKRouteParameters ret = *owner->contents.result;
1357 ret.is_owned = false;
1360 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_ok"))) TS_CResult_RouteParametersDecodeErrorZ_get_ok(uint64_t owner) {
1361 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
1362 LDKRouteParameters ret_var = CResult_RouteParametersDecodeErrorZ_get_ok(owner_conv);
1363 uint64_t ret_ref = 0;
1364 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1365 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1369 static inline struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1370 CHECK(!owner->result_ok);
1371 return DecodeError_clone(&*owner->contents.err);
1373 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_err"))) TS_CResult_RouteParametersDecodeErrorZ_get_err(uint64_t owner) {
1374 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
1375 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1376 *ret_copy = CResult_RouteParametersDecodeErrorZ_get_err(owner_conv);
1377 uint64_t ret_ref = tag_ptr(ret_copy, true);
1381 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
1382 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
1383 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
1386 static inline struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1387 LDKPaymentParameters ret = *owner->contents.result;
1388 ret.is_owned = false;
1391 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_get_ok(uint64_t owner) {
1392 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
1393 LDKPaymentParameters ret_var = CResult_PaymentParametersDecodeErrorZ_get_ok(owner_conv);
1394 uint64_t ret_ref = 0;
1395 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1396 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1400 static inline struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1401 CHECK(!owner->result_ok);
1402 return DecodeError_clone(&*owner->contents.err);
1404 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_err"))) TS_CResult_PaymentParametersDecodeErrorZ_get_err(uint64_t owner) {
1405 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
1406 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1407 *ret_copy = CResult_PaymentParametersDecodeErrorZ_get_err(owner_conv);
1408 uint64_t ret_ref = tag_ptr(ret_copy, true);
1412 static inline struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner){
1413 LDKBlindedPayInfo ret = owner->a;
1414 ret.is_owned = false;
1417 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(uint64_t owner) {
1418 LDKC2Tuple_BlindedPayInfoBlindedPathZ* owner_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(owner);
1419 LDKBlindedPayInfo ret_var = C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner_conv);
1420 uint64_t ret_ref = 0;
1421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1426 static inline struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner){
1427 LDKBlindedPath ret = owner->b;
1428 ret.is_owned = false;
1431 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(uint64_t owner) {
1432 LDKC2Tuple_BlindedPayInfoBlindedPathZ* owner_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(owner);
1433 LDKBlindedPath ret_var = C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner_conv);
1434 uint64_t ret_ref = 0;
1435 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1436 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1440 static inline LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_clone(const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ *orig) {
1441 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ) * orig->datalen, "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ clone bytes"), .datalen = orig->datalen };
1442 for (size_t i = 0; i < ret.datalen; i++) {
1443 ret.data[i] = C2Tuple_BlindedPayInfoBlindedPathZ_clone(&orig->data[i]);
1447 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
1448 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
1449 for (size_t i = 0; i < ret.datalen; i++) {
1450 ret.data[i] = RouteHint_clone(&orig->data[i]);
1454 static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
1455 LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
1456 for (size_t i = 0; i < ret.datalen; i++) {
1457 ret.data[i] = RouteHintHop_clone(&orig->data[i]);
1461 static inline struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1462 LDKRouteHint ret = *owner->contents.result;
1463 ret.is_owned = false;
1466 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_ok"))) TS_CResult_RouteHintDecodeErrorZ_get_ok(uint64_t owner) {
1467 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
1468 LDKRouteHint ret_var = CResult_RouteHintDecodeErrorZ_get_ok(owner_conv);
1469 uint64_t ret_ref = 0;
1470 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1471 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1475 static inline struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1476 CHECK(!owner->result_ok);
1477 return DecodeError_clone(&*owner->contents.err);
1479 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_err"))) TS_CResult_RouteHintDecodeErrorZ_get_err(uint64_t owner) {
1480 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
1481 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1482 *ret_copy = CResult_RouteHintDecodeErrorZ_get_err(owner_conv);
1483 uint64_t ret_ref = tag_ptr(ret_copy, true);
1487 static inline struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1488 LDKRouteHintHop ret = *owner->contents.result;
1489 ret.is_owned = false;
1492 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_get_ok(uint64_t owner) {
1493 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
1494 LDKRouteHintHop ret_var = CResult_RouteHintHopDecodeErrorZ_get_ok(owner_conv);
1495 uint64_t ret_ref = 0;
1496 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1497 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1501 static inline struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1502 CHECK(!owner->result_ok);
1503 return DecodeError_clone(&*owner->contents.err);
1505 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_err"))) TS_CResult_RouteHintHopDecodeErrorZ_get_err(uint64_t owner) {
1506 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
1507 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1508 *ret_copy = CResult_RouteHintHopDecodeErrorZ_get_err(owner_conv);
1509 uint64_t ret_ref = tag_ptr(ret_copy, true);
1513 static inline uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
1516 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_a"))) TS_C2Tuple_usizeTransactionZ_get_a(uint64_t owner) {
1517 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
1518 uint32_t ret_conv = C2Tuple_usizeTransactionZ_get_a(owner_conv);
1522 static inline struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
1525 int8_tArray __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_b"))) TS_C2Tuple_usizeTransactionZ_get_b(uint64_t owner) {
1526 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
1527 LDKTransaction ret_var = C2Tuple_usizeTransactionZ_get_b(owner_conv);
1528 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
1529 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
1533 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
1534 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
1535 for (size_t i = 0; i < ret.datalen; i++) {
1536 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
1540 static inline struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner){
1541 return ThirtyTwoBytes_clone(&owner->a);
1543 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_get_a"))) TS_C2Tuple_TxidBlockHashZ_get_a(uint64_t owner) {
1544 LDKC2Tuple_TxidBlockHashZ* owner_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(owner);
1545 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1546 memcpy(ret_arr->elems, C2Tuple_TxidBlockHashZ_get_a(owner_conv).data, 32);
1550 static inline struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner){
1551 return ThirtyTwoBytes_clone(&owner->b);
1553 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_get_b"))) TS_C2Tuple_TxidBlockHashZ_get_b(uint64_t owner) {
1554 LDKC2Tuple_TxidBlockHashZ* owner_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(owner);
1555 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1556 memcpy(ret_arr->elems, C2Tuple_TxidBlockHashZ_get_b(owner_conv).data, 32);
1560 static inline LDKCVec_C2Tuple_TxidBlockHashZZ CVec_C2Tuple_TxidBlockHashZZ_clone(const LDKCVec_C2Tuple_TxidBlockHashZZ *orig) {
1561 LDKCVec_C2Tuple_TxidBlockHashZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ) * orig->datalen, "LDKCVec_C2Tuple_TxidBlockHashZZ clone bytes"), .datalen = orig->datalen };
1562 for (size_t i = 0; i < ret.datalen; i++) {
1563 ret.data[i] = C2Tuple_TxidBlockHashZ_clone(&orig->data[i]);
1567 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_ty_from_ptr"))) TS_LDKMonitorEvent_ty_from_ptr(uint64_t ptr) {
1568 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1570 case LDKMonitorEvent_HTLCEvent: return 0;
1571 case LDKMonitorEvent_CommitmentTxConfirmed: return 1;
1572 case LDKMonitorEvent_Completed: return 2;
1573 case LDKMonitorEvent_UpdateFailed: return 3;
1577 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_HTLCEvent_get_htlc_event"))) TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(uint64_t ptr) {
1578 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1579 assert(obj->tag == LDKMonitorEvent_HTLCEvent);
1580 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
1581 uint64_t htlc_event_ref = 0;
1582 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
1583 htlc_event_ref = tag_ptr(htlc_event_var.inner, false);
1584 return htlc_event_ref;
1586 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed"))) TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(uint64_t ptr) {
1587 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1588 assert(obj->tag == LDKMonitorEvent_CommitmentTxConfirmed);
1589 LDKOutPoint commitment_tx_confirmed_var = obj->commitment_tx_confirmed;
1590 uint64_t commitment_tx_confirmed_ref = 0;
1591 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
1592 commitment_tx_confirmed_ref = tag_ptr(commitment_tx_confirmed_var.inner, false);
1593 return commitment_tx_confirmed_ref;
1595 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_funding_txo"))) TS_LDKMonitorEvent_Completed_get_funding_txo(uint64_t ptr) {
1596 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1597 assert(obj->tag == LDKMonitorEvent_Completed);
1598 LDKOutPoint funding_txo_var = obj->completed.funding_txo;
1599 uint64_t funding_txo_ref = 0;
1600 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
1601 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
1602 return funding_txo_ref;
1604 int64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_monitor_update_id"))) TS_LDKMonitorEvent_Completed_get_monitor_update_id(uint64_t ptr) {
1605 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1606 assert(obj->tag == LDKMonitorEvent_Completed);
1607 int64_t monitor_update_id_conv = obj->completed.monitor_update_id;
1608 return monitor_update_id_conv;
1610 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_UpdateFailed_get_update_failed"))) TS_LDKMonitorEvent_UpdateFailed_get_update_failed(uint64_t ptr) {
1611 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1612 assert(obj->tag == LDKMonitorEvent_UpdateFailed);
1613 LDKOutPoint update_failed_var = obj->update_failed;
1614 uint64_t update_failed_ref = 0;
1615 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
1616 update_failed_ref = tag_ptr(update_failed_var.inner, false);
1617 return update_failed_ref;
1619 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
1620 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
1621 for (size_t i = 0; i < ret.datalen; i++) {
1622 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
1626 static inline struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
1627 LDKOutPoint ret = owner->a;
1628 ret.is_owned = false;
1631 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(uint64_t owner) {
1632 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
1633 LDKOutPoint ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner_conv);
1634 uint64_t ret_ref = 0;
1635 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1636 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1640 static inline struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
1641 return CVec_MonitorEventZ_clone(&owner->b);
1643 uint64_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(uint64_t owner) {
1644 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
1645 LDKCVec_MonitorEventZ ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner_conv);
1646 uint64_tArray ret_arr = NULL;
1647 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
1648 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
1649 for (size_t o = 0; o < ret_var.datalen; o++) {
1650 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
1651 *ret_conv_14_copy = ret_var.data[o];
1652 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
1653 ret_arr_ptr[o] = ret_conv_14_ref;
1660 static inline struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
1663 int8_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(uint64_t owner) {
1664 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
1665 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
1666 memcpy(ret_arr->elems, C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner_conv).compressed_form, 33);
1670 static inline LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_clone(const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ *orig) {
1671 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ) * orig->datalen, "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ clone bytes"), .datalen = orig->datalen };
1672 for (size_t i = 0; i < ret.datalen; i++) {
1673 ret.data[i] = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(&orig->data[i]);
1677 static inline struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
1678 LDKFixedPenaltyScorer ret = *owner->contents.result;
1679 ret.is_owned = false;
1682 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(uint64_t owner) {
1683 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
1684 LDKFixedPenaltyScorer ret_var = CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner_conv);
1685 uint64_t ret_ref = 0;
1686 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1687 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1691 static inline struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
1692 CHECK(!owner->result_ok);
1693 return DecodeError_clone(&*owner->contents.err);
1695 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(uint64_t owner) {
1696 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
1697 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1698 *ret_copy = CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner_conv);
1699 uint64_t ret_ref = tag_ptr(ret_copy, true);
1703 static inline uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
1706 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_a"))) TS_C2Tuple_u64u64Z_get_a(uint64_t owner) {
1707 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
1708 int64_t ret_conv = C2Tuple_u64u64Z_get_a(owner_conv);
1712 static inline uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
1715 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_b"))) TS_C2Tuple_u64u64Z_get_b(uint64_t owner) {
1716 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
1717 int64_t ret_conv = C2Tuple_u64u64Z_get_b(owner_conv);
1721 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(uint64_t ptr) {
1722 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
1724 case LDKCOption_C2Tuple_u64u64ZZ_Some: return 0;
1725 case LDKCOption_C2Tuple_u64u64ZZ_None: return 1;
1729 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(uint64_t ptr) {
1730 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
1731 assert(obj->tag == LDKCOption_C2Tuple_u64u64ZZ_Some);
1732 LDKC2Tuple_u64u64Z* some_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
1733 *some_conv = obj->some;
1734 *some_conv = C2Tuple_u64u64Z_clone(some_conv);
1735 return tag_ptr(some_conv, true);
1737 static inline struct LDKEightU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner){
1740 int16_tArray __attribute__((export_name("TS_C2Tuple_Z_get_a"))) TS_C2Tuple_Z_get_a(uint64_t owner) {
1741 LDKC2Tuple_Z* owner_conv = (LDKC2Tuple_Z*)untag_ptr(owner);
1742 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1743 memcpy(ret_arr->elems, C2Tuple_Z_get_a(owner_conv).data, 8 * 2);
1747 static inline struct LDKEightU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner){
1750 int16_tArray __attribute__((export_name("TS_C2Tuple_Z_get_b"))) TS_C2Tuple_Z_get_b(uint64_t owner) {
1751 LDKC2Tuple_Z* owner_conv = (LDKC2Tuple_Z*)untag_ptr(owner);
1752 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1753 memcpy(ret_arr->elems, C2Tuple_Z_get_b(owner_conv).data, 8 * 2);
1757 static inline struct LDKEightU16s C2Tuple__u168_u168Z_get_a(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner){
1760 int16_tArray __attribute__((export_name("TS_C2Tuple__u168_u168Z_get_a"))) TS_C2Tuple__u168_u168Z_get_a(uint64_t owner) {
1761 LDKC2Tuple__u168_u168Z* owner_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(owner);
1762 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1763 memcpy(ret_arr->elems, C2Tuple__u168_u168Z_get_a(owner_conv).data, 8 * 2);
1767 static inline struct LDKEightU16s C2Tuple__u168_u168Z_get_b(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner){
1770 int16_tArray __attribute__((export_name("TS_C2Tuple__u168_u168Z_get_b"))) TS_C2Tuple__u168_u168Z_get_b(uint64_t owner) {
1771 LDKC2Tuple__u168_u168Z* owner_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(owner);
1772 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1773 memcpy(ret_arr->elems, C2Tuple__u168_u168Z_get_b(owner_conv).data, 8 * 2);
1777 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(uint64_t ptr) {
1778 LDKCOption_C2Tuple_EightU16sEightU16sZZ *obj = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(ptr);
1780 case LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some: return 0;
1781 case LDKCOption_C2Tuple_EightU16sEightU16sZZ_None: return 1;
1785 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(uint64_t ptr) {
1786 LDKCOption_C2Tuple_EightU16sEightU16sZZ *obj = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(ptr);
1787 assert(obj->tag == LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some);
1788 LDKC2Tuple__u168_u168Z* some_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
1789 *some_conv = obj->some;
1790 *some_conv = C2Tuple__u168_u168Z_clone(some_conv);
1791 return tag_ptr(some_conv, true);
1793 static inline LDKCVec_NodeIdZ CVec_NodeIdZ_clone(const LDKCVec_NodeIdZ *orig) {
1794 LDKCVec_NodeIdZ ret = { .data = MALLOC(sizeof(LDKNodeId) * orig->datalen, "LDKCVec_NodeIdZ clone bytes"), .datalen = orig->datalen };
1795 for (size_t i = 0; i < ret.datalen; i++) {
1796 ret.data[i] = NodeId_clone(&orig->data[i]);
1800 typedef struct LDKLogger_JCalls {
1801 atomic_size_t refcnt;
1802 uint32_t instance_ptr;
1804 static void LDKLogger_JCalls_free(void* this_arg) {
1805 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
1806 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
1810 void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
1811 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
1812 LDKRecord record_var = *record;
1813 uint64_t record_ref = 0;
1814 record_var = Record_clone(&record_var);
1815 CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
1816 record_ref = tag_ptr(record_var.inner, record_var.is_owned);
1817 js_invoke_function_buuuuu(j_calls->instance_ptr, 0, record_ref, 0, 0, 0, 0, 0);
1819 static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
1820 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
1821 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
1823 static inline LDKLogger LDKLogger_init (JSValue o) {
1824 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
1825 atomic_init(&calls->refcnt, 1);
1826 calls->instance_ptr = o;
1829 .this_arg = (void*) calls,
1830 .log = log_LDKLogger_jcall,
1831 .free = LDKLogger_JCalls_free,
1835 uint64_t __attribute__((export_name("TS_LDKLogger_new"))) TS_LDKLogger_new(JSValue o) {
1836 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
1837 *res_ptr = LDKLogger_init(o);
1838 return tag_ptr(res_ptr, true);
1840 static inline struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
1841 LDKProbabilisticScorer ret = *owner->contents.result;
1842 ret.is_owned = false;
1845 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(uint64_t owner) {
1846 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
1847 LDKProbabilisticScorer ret_var = CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner_conv);
1848 uint64_t ret_ref = 0;
1849 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1850 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1854 static inline struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
1855 CHECK(!owner->result_ok);
1856 return DecodeError_clone(&*owner->contents.err);
1858 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(uint64_t owner) {
1859 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
1860 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1861 *ret_copy = CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner_conv);
1862 uint64_t ret_ref = tag_ptr(ret_copy, true);
1866 static inline struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
1867 LDKInitFeatures ret = *owner->contents.result;
1868 ret.is_owned = false;
1871 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1872 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
1873 LDKInitFeatures ret_var = CResult_InitFeaturesDecodeErrorZ_get_ok(owner_conv);
1874 uint64_t ret_ref = 0;
1875 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1876 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1880 static inline struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
1881 CHECK(!owner->result_ok);
1882 return DecodeError_clone(&*owner->contents.err);
1884 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_err"))) TS_CResult_InitFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1885 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
1886 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1887 *ret_copy = CResult_InitFeaturesDecodeErrorZ_get_err(owner_conv);
1888 uint64_t ret_ref = tag_ptr(ret_copy, true);
1892 static inline struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
1893 LDKChannelFeatures ret = *owner->contents.result;
1894 ret.is_owned = false;
1897 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1898 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
1899 LDKChannelFeatures ret_var = CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner_conv);
1900 uint64_t ret_ref = 0;
1901 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1902 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1906 static inline struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
1907 CHECK(!owner->result_ok);
1908 return DecodeError_clone(&*owner->contents.err);
1910 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1911 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
1912 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1913 *ret_copy = CResult_ChannelFeaturesDecodeErrorZ_get_err(owner_conv);
1914 uint64_t ret_ref = tag_ptr(ret_copy, true);
1918 static inline struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
1919 LDKNodeFeatures ret = *owner->contents.result;
1920 ret.is_owned = false;
1923 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1924 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
1925 LDKNodeFeatures ret_var = CResult_NodeFeaturesDecodeErrorZ_get_ok(owner_conv);
1926 uint64_t ret_ref = 0;
1927 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1928 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1932 static inline struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
1933 CHECK(!owner->result_ok);
1934 return DecodeError_clone(&*owner->contents.err);
1936 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1937 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
1938 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1939 *ret_copy = CResult_NodeFeaturesDecodeErrorZ_get_err(owner_conv);
1940 uint64_t ret_ref = tag_ptr(ret_copy, true);
1944 static inline struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
1945 LDKInvoiceFeatures ret = *owner->contents.result;
1946 ret.is_owned = false;
1949 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1950 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
1951 LDKInvoiceFeatures ret_var = CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner_conv);
1952 uint64_t ret_ref = 0;
1953 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1954 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1958 static inline struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
1959 CHECK(!owner->result_ok);
1960 return DecodeError_clone(&*owner->contents.err);
1962 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1963 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
1964 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1965 *ret_copy = CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner_conv);
1966 uint64_t ret_ref = tag_ptr(ret_copy, true);
1970 static inline struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner){
1971 LDKBlindedHopFeatures ret = *owner->contents.result;
1972 ret.is_owned = false;
1975 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1976 LDKCResult_BlindedHopFeaturesDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(owner);
1977 LDKBlindedHopFeatures ret_var = CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner_conv);
1978 uint64_t ret_ref = 0;
1979 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1980 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1984 static inline struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner){
1985 CHECK(!owner->result_ok);
1986 return DecodeError_clone(&*owner->contents.err);
1988 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1989 LDKCResult_BlindedHopFeaturesDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(owner);
1990 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1991 *ret_copy = CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner_conv);
1992 uint64_t ret_ref = tag_ptr(ret_copy, true);
1996 static inline struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
1997 LDKChannelTypeFeatures ret = *owner->contents.result;
1998 ret.is_owned = false;
2001 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2002 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
2003 LDKChannelTypeFeatures ret_var = CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner_conv);
2004 uint64_t ret_ref = 0;
2005 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2006 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2010 static inline struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
2011 CHECK(!owner->result_ok);
2012 return DecodeError_clone(&*owner->contents.err);
2014 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2015 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
2016 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2017 *ret_copy = CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner_conv);
2018 uint64_t ret_ref = tag_ptr(ret_copy, true);
2022 uint32_t __attribute__((export_name("TS_LDKPaymentPurpose_ty_from_ptr"))) TS_LDKPaymentPurpose_ty_from_ptr(uint64_t ptr) {
2023 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2025 case LDKPaymentPurpose_InvoicePayment: return 0;
2026 case LDKPaymentPurpose_SpontaneousPayment: return 1;
2030 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(uint64_t ptr) {
2031 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2032 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
2033 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
2034 memcpy(payment_preimage_arr->elems, obj->invoice_payment.payment_preimage.data, 32);
2035 return payment_preimage_arr;
2037 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(uint64_t ptr) {
2038 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2039 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
2040 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
2041 memcpy(payment_secret_arr->elems, obj->invoice_payment.payment_secret.data, 32);
2042 return payment_secret_arr;
2044 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment"))) TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(uint64_t ptr) {
2045 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2046 assert(obj->tag == LDKPaymentPurpose_SpontaneousPayment);
2047 int8_tArray spontaneous_payment_arr = init_int8_tArray(32, __LINE__);
2048 memcpy(spontaneous_payment_arr->elems, obj->spontaneous_payment.data, 32);
2049 return spontaneous_payment_arr;
2051 static inline struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
2052 CHECK(owner->result_ok);
2053 return PaymentPurpose_clone(&*owner->contents.result);
2055 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(uint64_t owner) {
2056 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
2057 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
2058 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_ok(owner_conv);
2059 uint64_t ret_ref = tag_ptr(ret_copy, true);
2063 static inline struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
2064 CHECK(!owner->result_ok);
2065 return DecodeError_clone(&*owner->contents.err);
2067 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_err(uint64_t owner) {
2068 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
2069 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2070 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_err(owner_conv);
2071 uint64_t ret_ref = tag_ptr(ret_copy, true);
2075 uint32_t __attribute__((export_name("TS_LDKNetworkUpdate_ty_from_ptr"))) TS_LDKNetworkUpdate_ty_from_ptr(uint64_t ptr) {
2076 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2078 case LDKNetworkUpdate_ChannelUpdateMessage: return 0;
2079 case LDKNetworkUpdate_ChannelFailure: return 1;
2080 case LDKNetworkUpdate_NodeFailure: return 2;
2084 uint64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg"))) TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(uint64_t ptr) {
2085 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2086 assert(obj->tag == LDKNetworkUpdate_ChannelUpdateMessage);
2087 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
2088 uint64_t msg_ref = 0;
2089 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2090 msg_ref = tag_ptr(msg_var.inner, false);
2093 int64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id"))) TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(uint64_t ptr) {
2094 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2095 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
2096 int64_t short_channel_id_conv = obj->channel_failure.short_channel_id;
2097 return short_channel_id_conv;
2099 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent"))) TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(uint64_t ptr) {
2100 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2101 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
2102 jboolean is_permanent_conv = obj->channel_failure.is_permanent;
2103 return is_permanent_conv;
2105 int8_tArray __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_node_id"))) TS_LDKNetworkUpdate_NodeFailure_get_node_id(uint64_t ptr) {
2106 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2107 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
2108 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2109 memcpy(node_id_arr->elems, obj->node_failure.node_id.compressed_form, 33);
2112 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_is_permanent"))) TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(uint64_t ptr) {
2113 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2114 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
2115 jboolean is_permanent_conv = obj->node_failure.is_permanent;
2116 return is_permanent_conv;
2118 uint32_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_ty_from_ptr"))) TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(uint64_t ptr) {
2119 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
2121 case LDKCOption_NetworkUpdateZ_Some: return 0;
2122 case LDKCOption_NetworkUpdateZ_None: return 1;
2126 uint64_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_Some_get_some"))) TS_LDKCOption_NetworkUpdateZ_Some_get_some(uint64_t ptr) {
2127 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
2128 assert(obj->tag == LDKCOption_NetworkUpdateZ_Some);
2129 uint64_t some_ref = tag_ptr(&obj->some, false);
2132 uint32_t __attribute__((export_name("TS_LDKPathFailure_ty_from_ptr"))) TS_LDKPathFailure_ty_from_ptr(uint64_t ptr) {
2133 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
2135 case LDKPathFailure_InitialSend: return 0;
2136 case LDKPathFailure_OnPath: return 1;
2140 uint64_t __attribute__((export_name("TS_LDKPathFailure_InitialSend_get_err"))) TS_LDKPathFailure_InitialSend_get_err(uint64_t ptr) {
2141 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
2142 assert(obj->tag == LDKPathFailure_InitialSend);
2143 uint64_t err_ref = tag_ptr(&obj->initial_send.err, false);
2146 uint64_t __attribute__((export_name("TS_LDKPathFailure_OnPath_get_network_update"))) TS_LDKPathFailure_OnPath_get_network_update(uint64_t ptr) {
2147 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
2148 assert(obj->tag == LDKPathFailure_OnPath);
2149 uint64_t network_update_ref = tag_ptr(&obj->on_path.network_update, false);
2150 return network_update_ref;
2152 uint32_t __attribute__((export_name("TS_LDKCOption_PathFailureZ_ty_from_ptr"))) TS_LDKCOption_PathFailureZ_ty_from_ptr(uint64_t ptr) {
2153 LDKCOption_PathFailureZ *obj = (LDKCOption_PathFailureZ*)untag_ptr(ptr);
2155 case LDKCOption_PathFailureZ_Some: return 0;
2156 case LDKCOption_PathFailureZ_None: return 1;
2160 uint64_t __attribute__((export_name("TS_LDKCOption_PathFailureZ_Some_get_some"))) TS_LDKCOption_PathFailureZ_Some_get_some(uint64_t ptr) {
2161 LDKCOption_PathFailureZ *obj = (LDKCOption_PathFailureZ*)untag_ptr(ptr);
2162 assert(obj->tag == LDKCOption_PathFailureZ_Some);
2163 uint64_t some_ref = tag_ptr(&obj->some, false);
2166 static inline struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner){
2167 CHECK(owner->result_ok);
2168 return COption_PathFailureZ_clone(&*owner->contents.result);
2170 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(uint64_t owner) {
2171 LDKCResult_COption_PathFailureZDecodeErrorZ* owner_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(owner);
2172 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
2173 *ret_copy = CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner_conv);
2174 uint64_t ret_ref = tag_ptr(ret_copy, true);
2178 static inline struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner){
2179 CHECK(!owner->result_ok);
2180 return DecodeError_clone(&*owner->contents.err);
2182 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_get_err"))) TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(uint64_t owner) {
2183 LDKCResult_COption_PathFailureZDecodeErrorZ* owner_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(owner);
2184 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2185 *ret_copy = CResult_COption_PathFailureZDecodeErrorZ_get_err(owner_conv);
2186 uint64_t ret_ref = tag_ptr(ret_copy, true);
2190 uint32_t __attribute__((export_name("TS_LDKClosureReason_ty_from_ptr"))) TS_LDKClosureReason_ty_from_ptr(uint64_t ptr) {
2191 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
2193 case LDKClosureReason_CounterpartyForceClosed: return 0;
2194 case LDKClosureReason_HolderForceClosed: return 1;
2195 case LDKClosureReason_CooperativeClosure: return 2;
2196 case LDKClosureReason_CommitmentTxConfirmed: return 3;
2197 case LDKClosureReason_FundingTimedOut: return 4;
2198 case LDKClosureReason_ProcessingError: return 5;
2199 case LDKClosureReason_DisconnectedPeer: return 6;
2200 case LDKClosureReason_OutdatedChannelManager: return 7;
2204 uint64_t __attribute__((export_name("TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg"))) TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(uint64_t ptr) {
2205 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
2206 assert(obj->tag == LDKClosureReason_CounterpartyForceClosed);
2207 LDKUntrustedString peer_msg_var = obj->counterparty_force_closed.peer_msg;
2208 uint64_t peer_msg_ref = 0;
2209 CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_msg_var);
2210 peer_msg_ref = tag_ptr(peer_msg_var.inner, false);
2211 return peer_msg_ref;
2213 jstring __attribute__((export_name("TS_LDKClosureReason_ProcessingError_get_err"))) TS_LDKClosureReason_ProcessingError_get_err(uint64_t ptr) {
2214 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
2215 assert(obj->tag == LDKClosureReason_ProcessingError);
2216 LDKStr err_str = obj->processing_error.err;
2217 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
2220 uint32_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_ty_from_ptr"))) TS_LDKCOption_ClosureReasonZ_ty_from_ptr(uint64_t ptr) {
2221 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
2223 case LDKCOption_ClosureReasonZ_Some: return 0;
2224 case LDKCOption_ClosureReasonZ_None: return 1;
2228 uint64_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_Some_get_some"))) TS_LDKCOption_ClosureReasonZ_Some_get_some(uint64_t ptr) {
2229 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
2230 assert(obj->tag == LDKCOption_ClosureReasonZ_Some);
2231 uint64_t some_ref = tag_ptr(&obj->some, false);
2234 static inline struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
2235 CHECK(owner->result_ok);
2236 return COption_ClosureReasonZ_clone(&*owner->contents.result);
2238 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint64_t owner) {
2239 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
2240 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
2241 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner_conv);
2242 uint64_t ret_ref = tag_ptr(ret_copy, true);
2246 static inline struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
2247 CHECK(!owner->result_ok);
2248 return DecodeError_clone(&*owner->contents.err);
2250 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint64_t owner) {
2251 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
2252 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2253 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner_conv);
2254 uint64_t ret_ref = tag_ptr(ret_copy, true);
2258 uint32_t __attribute__((export_name("TS_LDKHTLCDestination_ty_from_ptr"))) TS_LDKHTLCDestination_ty_from_ptr(uint64_t ptr) {
2259 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2261 case LDKHTLCDestination_NextHopChannel: return 0;
2262 case LDKHTLCDestination_UnknownNextHop: return 1;
2263 case LDKHTLCDestination_InvalidForward: return 2;
2264 case LDKHTLCDestination_FailedPayment: return 3;
2268 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_node_id"))) TS_LDKHTLCDestination_NextHopChannel_get_node_id(uint64_t ptr) {
2269 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2270 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
2271 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2272 memcpy(node_id_arr->elems, obj->next_hop_channel.node_id.compressed_form, 33);
2275 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_channel_id"))) TS_LDKHTLCDestination_NextHopChannel_get_channel_id(uint64_t ptr) {
2276 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2277 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
2278 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2279 memcpy(channel_id_arr->elems, obj->next_hop_channel.channel_id.data, 32);
2280 return channel_id_arr;
2282 int64_t __attribute__((export_name("TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid"))) TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(uint64_t ptr) {
2283 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2284 assert(obj->tag == LDKHTLCDestination_UnknownNextHop);
2285 int64_t requested_forward_scid_conv = obj->unknown_next_hop.requested_forward_scid;
2286 return requested_forward_scid_conv;
2288 int64_t __attribute__((export_name("TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid"))) TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(uint64_t ptr) {
2289 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2290 assert(obj->tag == LDKHTLCDestination_InvalidForward);
2291 int64_t requested_forward_scid_conv = obj->invalid_forward.requested_forward_scid;
2292 return requested_forward_scid_conv;
2294 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_FailedPayment_get_payment_hash"))) TS_LDKHTLCDestination_FailedPayment_get_payment_hash(uint64_t ptr) {
2295 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2296 assert(obj->tag == LDKHTLCDestination_FailedPayment);
2297 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2298 memcpy(payment_hash_arr->elems, obj->failed_payment.payment_hash.data, 32);
2299 return payment_hash_arr;
2301 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_ty_from_ptr"))) TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(uint64_t ptr) {
2302 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
2304 case LDKCOption_HTLCDestinationZ_Some: return 0;
2305 case LDKCOption_HTLCDestinationZ_None: return 1;
2309 uint64_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_Some_get_some"))) TS_LDKCOption_HTLCDestinationZ_Some_get_some(uint64_t ptr) {
2310 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
2311 assert(obj->tag == LDKCOption_HTLCDestinationZ_Some);
2312 uint64_t some_ref = tag_ptr(&obj->some, false);
2315 static inline struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
2316 CHECK(owner->result_ok);
2317 return COption_HTLCDestinationZ_clone(&*owner->contents.result);
2319 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(uint64_t owner) {
2320 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
2321 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
2322 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner_conv);
2323 uint64_t ret_ref = tag_ptr(ret_copy, true);
2327 static inline struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
2328 CHECK(!owner->result_ok);
2329 return DecodeError_clone(&*owner->contents.err);
2331 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(uint64_t owner) {
2332 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
2333 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2334 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner_conv);
2335 uint64_t ret_ref = tag_ptr(ret_copy, true);
2339 static inline enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner){
2340 CHECK(owner->result_ok);
2341 return PaymentFailureReason_clone(&*owner->contents.result);
2343 uint32_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(uint64_t owner) {
2344 LDKCResult_PaymentFailureReasonDecodeErrorZ* owner_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(owner);
2345 uint32_t ret_conv = LDKPaymentFailureReason_to_js(CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner_conv));
2349 static inline struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner){
2350 CHECK(!owner->result_ok);
2351 return DecodeError_clone(&*owner->contents.err);
2353 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(uint64_t owner) {
2354 LDKCResult_PaymentFailureReasonDecodeErrorZ* owner_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(owner);
2355 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2356 *ret_copy = CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner_conv);
2357 uint64_t ret_ref = tag_ptr(ret_copy, true);
2361 uint32_t __attribute__((export_name("TS_LDKCOption_u128Z_ty_from_ptr"))) TS_LDKCOption_u128Z_ty_from_ptr(uint64_t ptr) {
2362 LDKCOption_u128Z *obj = (LDKCOption_u128Z*)untag_ptr(ptr);
2364 case LDKCOption_u128Z_Some: return 0;
2365 case LDKCOption_u128Z_None: return 1;
2369 int8_tArray __attribute__((export_name("TS_LDKCOption_u128Z_Some_get_some"))) TS_LDKCOption_u128Z_Some_get_some(uint64_t ptr) {
2370 LDKCOption_u128Z *obj = (LDKCOption_u128Z*)untag_ptr(ptr);
2371 assert(obj->tag == LDKCOption_u128Z_Some);
2372 int8_tArray some_arr = init_int8_tArray(16, __LINE__);
2373 memcpy(some_arr->elems, obj->some.le_bytes, 16);
2376 uint32_t __attribute__((export_name("TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr"))) TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(uint64_t ptr) {
2377 LDKCOption_PaymentFailureReasonZ *obj = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(ptr);
2379 case LDKCOption_PaymentFailureReasonZ_Some: return 0;
2380 case LDKCOption_PaymentFailureReasonZ_None: return 1;
2384 uint32_t __attribute__((export_name("TS_LDKCOption_PaymentFailureReasonZ_Some_get_some"))) TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(uint64_t ptr) {
2385 LDKCOption_PaymentFailureReasonZ *obj = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(ptr);
2386 assert(obj->tag == LDKCOption_PaymentFailureReasonZ_Some);
2387 uint32_t some_conv = LDKPaymentFailureReason_to_js(obj->some);
2390 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_ty_from_ptr"))) TS_LDKSpendableOutputDescriptor_ty_from_ptr(uint64_t ptr) {
2391 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2393 case LDKSpendableOutputDescriptor_StaticOutput: return 0;
2394 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: return 1;
2395 case LDKSpendableOutputDescriptor_StaticPaymentOutput: return 2;
2399 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(uint64_t ptr) {
2400 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2401 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
2402 LDKOutPoint outpoint_var = obj->static_output.outpoint;
2403 uint64_t outpoint_ref = 0;
2404 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
2405 outpoint_ref = tag_ptr(outpoint_var.inner, false);
2406 return outpoint_ref;
2408 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_output"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(uint64_t ptr) {
2409 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2410 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
2411 LDKTxOut* output_ref = &obj->static_output.output;
2412 return tag_ptr(output_ref, false);
2414 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output"))) TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(uint64_t ptr) {
2415 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2416 assert(obj->tag == LDKSpendableOutputDescriptor_DelayedPaymentOutput);
2417 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
2418 uint64_t delayed_payment_output_ref = 0;
2419 CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
2420 delayed_payment_output_ref = tag_ptr(delayed_payment_output_var.inner, false);
2421 return delayed_payment_output_ref;
2423 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output"))) TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(uint64_t ptr) {
2424 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2425 assert(obj->tag == LDKSpendableOutputDescriptor_StaticPaymentOutput);
2426 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
2427 uint64_t static_payment_output_ref = 0;
2428 CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
2429 static_payment_output_ref = tag_ptr(static_payment_output_var.inner, false);
2430 return static_payment_output_ref;
2432 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
2433 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
2434 for (size_t i = 0; i < ret.datalen; i++) {
2435 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
2439 uint32_t __attribute__((export_name("TS_LDKEvent_ty_from_ptr"))) TS_LDKEvent_ty_from_ptr(uint64_t ptr) {
2440 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2442 case LDKEvent_FundingGenerationReady: return 0;
2443 case LDKEvent_PaymentClaimable: return 1;
2444 case LDKEvent_PaymentClaimed: return 2;
2445 case LDKEvent_PaymentSent: return 3;
2446 case LDKEvent_PaymentFailed: return 4;
2447 case LDKEvent_PaymentPathSuccessful: return 5;
2448 case LDKEvent_PaymentPathFailed: return 6;
2449 case LDKEvent_ProbeSuccessful: return 7;
2450 case LDKEvent_ProbeFailed: return 8;
2451 case LDKEvent_PendingHTLCsForwardable: return 9;
2452 case LDKEvent_HTLCIntercepted: return 10;
2453 case LDKEvent_SpendableOutputs: return 11;
2454 case LDKEvent_PaymentForwarded: return 12;
2455 case LDKEvent_ChannelPending: return 13;
2456 case LDKEvent_ChannelReady: return 14;
2457 case LDKEvent_ChannelClosed: return 15;
2458 case LDKEvent_DiscardFunding: return 16;
2459 case LDKEvent_OpenChannelRequest: return 17;
2460 case LDKEvent_HTLCHandlingFailed: return 18;
2464 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(uint64_t ptr) {
2465 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2466 assert(obj->tag == LDKEvent_FundingGenerationReady);
2467 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2468 memcpy(temporary_channel_id_arr->elems, obj->funding_generation_ready.temporary_channel_id.data, 32);
2469 return temporary_channel_id_arr;
2471 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id"))) TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(uint64_t ptr) {
2472 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2473 assert(obj->tag == LDKEvent_FundingGenerationReady);
2474 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2475 memcpy(counterparty_node_id_arr->elems, obj->funding_generation_ready.counterparty_node_id.compressed_form, 33);
2476 return counterparty_node_id_arr;
2478 int64_t __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis"))) TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(uint64_t ptr) {
2479 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2480 assert(obj->tag == LDKEvent_FundingGenerationReady);
2481 int64_t channel_value_satoshis_conv = obj->funding_generation_ready.channel_value_satoshis;
2482 return channel_value_satoshis_conv;
2484 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_output_script"))) TS_LDKEvent_FundingGenerationReady_get_output_script(uint64_t ptr) {
2485 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2486 assert(obj->tag == LDKEvent_FundingGenerationReady);
2487 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
2488 int8_tArray output_script_arr = init_int8_tArray(output_script_var.datalen, __LINE__);
2489 memcpy(output_script_arr->elems, output_script_var.data, output_script_var.datalen);
2490 return output_script_arr;
2492 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_user_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_user_channel_id(uint64_t ptr) {
2493 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2494 assert(obj->tag == LDKEvent_FundingGenerationReady);
2495 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2496 memcpy(user_channel_id_arr->elems, obj->funding_generation_ready.user_channel_id.le_bytes, 16);
2497 return user_channel_id_arr;
2499 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimable_get_receiver_node_id(uint64_t ptr) {
2500 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2501 assert(obj->tag == LDKEvent_PaymentClaimable);
2502 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
2503 memcpy(receiver_node_id_arr->elems, obj->payment_claimable.receiver_node_id.compressed_form, 33);
2504 return receiver_node_id_arr;
2506 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_payment_hash"))) TS_LDKEvent_PaymentClaimable_get_payment_hash(uint64_t ptr) {
2507 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2508 assert(obj->tag == LDKEvent_PaymentClaimable);
2509 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2510 memcpy(payment_hash_arr->elems, obj->payment_claimable.payment_hash.data, 32);
2511 return payment_hash_arr;
2513 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_onion_fields"))) TS_LDKEvent_PaymentClaimable_get_onion_fields(uint64_t ptr) {
2514 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2515 assert(obj->tag == LDKEvent_PaymentClaimable);
2516 LDKRecipientOnionFields onion_fields_var = obj->payment_claimable.onion_fields;
2517 uint64_t onion_fields_ref = 0;
2518 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_fields_var);
2519 onion_fields_ref = tag_ptr(onion_fields_var.inner, false);
2520 return onion_fields_ref;
2522 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_amount_msat"))) TS_LDKEvent_PaymentClaimable_get_amount_msat(uint64_t ptr) {
2523 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2524 assert(obj->tag == LDKEvent_PaymentClaimable);
2525 int64_t amount_msat_conv = obj->payment_claimable.amount_msat;
2526 return amount_msat_conv;
2528 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_purpose"))) TS_LDKEvent_PaymentClaimable_get_purpose(uint64_t ptr) {
2529 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2530 assert(obj->tag == LDKEvent_PaymentClaimable);
2531 uint64_t purpose_ref = tag_ptr(&obj->payment_claimable.purpose, false);
2534 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_channel_id(uint64_t ptr) {
2535 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2536 assert(obj->tag == LDKEvent_PaymentClaimable);
2537 int8_tArray via_channel_id_arr = init_int8_tArray(32, __LINE__);
2538 memcpy(via_channel_id_arr->elems, obj->payment_claimable.via_channel_id.data, 32);
2539 return via_channel_id_arr;
2541 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_user_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(uint64_t ptr) {
2542 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2543 assert(obj->tag == LDKEvent_PaymentClaimable);
2544 uint64_t via_user_channel_id_ref = tag_ptr(&obj->payment_claimable.via_user_channel_id, false);
2545 return via_user_channel_id_ref;
2547 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_claim_deadline"))) TS_LDKEvent_PaymentClaimable_get_claim_deadline(uint64_t ptr) {
2548 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2549 assert(obj->tag == LDKEvent_PaymentClaimable);
2550 uint64_t claim_deadline_ref = tag_ptr(&obj->payment_claimable.claim_deadline, false);
2551 return claim_deadline_ref;
2553 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimed_get_receiver_node_id(uint64_t ptr) {
2554 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2555 assert(obj->tag == LDKEvent_PaymentClaimed);
2556 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
2557 memcpy(receiver_node_id_arr->elems, obj->payment_claimed.receiver_node_id.compressed_form, 33);
2558 return receiver_node_id_arr;
2560 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_payment_hash"))) TS_LDKEvent_PaymentClaimed_get_payment_hash(uint64_t ptr) {
2561 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2562 assert(obj->tag == LDKEvent_PaymentClaimed);
2563 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2564 memcpy(payment_hash_arr->elems, obj->payment_claimed.payment_hash.data, 32);
2565 return payment_hash_arr;
2567 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_amount_msat"))) TS_LDKEvent_PaymentClaimed_get_amount_msat(uint64_t ptr) {
2568 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2569 assert(obj->tag == LDKEvent_PaymentClaimed);
2570 int64_t amount_msat_conv = obj->payment_claimed.amount_msat;
2571 return amount_msat_conv;
2573 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_purpose"))) TS_LDKEvent_PaymentClaimed_get_purpose(uint64_t ptr) {
2574 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2575 assert(obj->tag == LDKEvent_PaymentClaimed);
2576 uint64_t purpose_ref = tag_ptr(&obj->payment_claimed.purpose, false);
2579 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_id"))) TS_LDKEvent_PaymentSent_get_payment_id(uint64_t ptr) {
2580 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2581 assert(obj->tag == LDKEvent_PaymentSent);
2582 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2583 memcpy(payment_id_arr->elems, obj->payment_sent.payment_id.data, 32);
2584 return payment_id_arr;
2586 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_preimage"))) TS_LDKEvent_PaymentSent_get_payment_preimage(uint64_t ptr) {
2587 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2588 assert(obj->tag == LDKEvent_PaymentSent);
2589 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
2590 memcpy(payment_preimage_arr->elems, obj->payment_sent.payment_preimage.data, 32);
2591 return payment_preimage_arr;
2593 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_hash"))) TS_LDKEvent_PaymentSent_get_payment_hash(uint64_t ptr) {
2594 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2595 assert(obj->tag == LDKEvent_PaymentSent);
2596 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2597 memcpy(payment_hash_arr->elems, obj->payment_sent.payment_hash.data, 32);
2598 return payment_hash_arr;
2600 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentSent_get_fee_paid_msat"))) TS_LDKEvent_PaymentSent_get_fee_paid_msat(uint64_t ptr) {
2601 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2602 assert(obj->tag == LDKEvent_PaymentSent);
2603 uint64_t fee_paid_msat_ref = tag_ptr(&obj->payment_sent.fee_paid_msat, false);
2604 return fee_paid_msat_ref;
2606 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_id"))) TS_LDKEvent_PaymentFailed_get_payment_id(uint64_t ptr) {
2607 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2608 assert(obj->tag == LDKEvent_PaymentFailed);
2609 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2610 memcpy(payment_id_arr->elems, obj->payment_failed.payment_id.data, 32);
2611 return payment_id_arr;
2613 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_hash"))) TS_LDKEvent_PaymentFailed_get_payment_hash(uint64_t ptr) {
2614 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2615 assert(obj->tag == LDKEvent_PaymentFailed);
2616 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2617 memcpy(payment_hash_arr->elems, obj->payment_failed.payment_hash.data, 32);
2618 return payment_hash_arr;
2620 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_reason"))) TS_LDKEvent_PaymentFailed_get_reason(uint64_t ptr) {
2621 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2622 assert(obj->tag == LDKEvent_PaymentFailed);
2623 uint64_t reason_ref = tag_ptr(&obj->payment_failed.reason, false);
2626 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_id"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_id(uint64_t ptr) {
2627 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2628 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
2629 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2630 memcpy(payment_id_arr->elems, obj->payment_path_successful.payment_id.data, 32);
2631 return payment_id_arr;
2633 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_hash"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(uint64_t ptr) {
2634 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2635 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
2636 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2637 memcpy(payment_hash_arr->elems, obj->payment_path_successful.payment_hash.data, 32);
2638 return payment_hash_arr;
2640 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_path"))) TS_LDKEvent_PaymentPathSuccessful_get_path(uint64_t ptr) {
2641 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2642 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
2643 LDKPath path_var = obj->payment_path_successful.path;
2644 uint64_t path_ref = 0;
2645 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2646 path_ref = tag_ptr(path_var.inner, false);
2649 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_id"))) TS_LDKEvent_PaymentPathFailed_get_payment_id(uint64_t ptr) {
2650 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2651 assert(obj->tag == LDKEvent_PaymentPathFailed);
2652 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2653 memcpy(payment_id_arr->elems, obj->payment_path_failed.payment_id.data, 32);
2654 return payment_id_arr;
2656 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_hash"))) TS_LDKEvent_PaymentPathFailed_get_payment_hash(uint64_t ptr) {
2657 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2658 assert(obj->tag == LDKEvent_PaymentPathFailed);
2659 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2660 memcpy(payment_hash_arr->elems, obj->payment_path_failed.payment_hash.data, 32);
2661 return payment_hash_arr;
2663 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently"))) TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(uint64_t ptr) {
2664 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2665 assert(obj->tag == LDKEvent_PaymentPathFailed);
2666 jboolean payment_failed_permanently_conv = obj->payment_path_failed.payment_failed_permanently;
2667 return payment_failed_permanently_conv;
2669 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_failure"))) TS_LDKEvent_PaymentPathFailed_get_failure(uint64_t ptr) {
2670 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2671 assert(obj->tag == LDKEvent_PaymentPathFailed);
2672 uint64_t failure_ref = tag_ptr(&obj->payment_path_failed.failure, false);
2675 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_path"))) TS_LDKEvent_PaymentPathFailed_get_path(uint64_t ptr) {
2676 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2677 assert(obj->tag == LDKEvent_PaymentPathFailed);
2678 LDKPath path_var = obj->payment_path_failed.path;
2679 uint64_t path_ref = 0;
2680 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2681 path_ref = tag_ptr(path_var.inner, false);
2684 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_short_channel_id"))) TS_LDKEvent_PaymentPathFailed_get_short_channel_id(uint64_t ptr) {
2685 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2686 assert(obj->tag == LDKEvent_PaymentPathFailed);
2687 uint64_t short_channel_id_ref = tag_ptr(&obj->payment_path_failed.short_channel_id, false);
2688 return short_channel_id_ref;
2690 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_id"))) TS_LDKEvent_ProbeSuccessful_get_payment_id(uint64_t ptr) {
2691 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2692 assert(obj->tag == LDKEvent_ProbeSuccessful);
2693 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2694 memcpy(payment_id_arr->elems, obj->probe_successful.payment_id.data, 32);
2695 return payment_id_arr;
2697 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_hash"))) TS_LDKEvent_ProbeSuccessful_get_payment_hash(uint64_t ptr) {
2698 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2699 assert(obj->tag == LDKEvent_ProbeSuccessful);
2700 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2701 memcpy(payment_hash_arr->elems, obj->probe_successful.payment_hash.data, 32);
2702 return payment_hash_arr;
2704 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_path"))) TS_LDKEvent_ProbeSuccessful_get_path(uint64_t ptr) {
2705 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2706 assert(obj->tag == LDKEvent_ProbeSuccessful);
2707 LDKPath path_var = obj->probe_successful.path;
2708 uint64_t path_ref = 0;
2709 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2710 path_ref = tag_ptr(path_var.inner, false);
2713 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_id"))) TS_LDKEvent_ProbeFailed_get_payment_id(uint64_t ptr) {
2714 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2715 assert(obj->tag == LDKEvent_ProbeFailed);
2716 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2717 memcpy(payment_id_arr->elems, obj->probe_failed.payment_id.data, 32);
2718 return payment_id_arr;
2720 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_hash"))) TS_LDKEvent_ProbeFailed_get_payment_hash(uint64_t ptr) {
2721 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2722 assert(obj->tag == LDKEvent_ProbeFailed);
2723 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2724 memcpy(payment_hash_arr->elems, obj->probe_failed.payment_hash.data, 32);
2725 return payment_hash_arr;
2727 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_path"))) TS_LDKEvent_ProbeFailed_get_path(uint64_t ptr) {
2728 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2729 assert(obj->tag == LDKEvent_ProbeFailed);
2730 LDKPath path_var = obj->probe_failed.path;
2731 uint64_t path_ref = 0;
2732 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2733 path_ref = tag_ptr(path_var.inner, false);
2736 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_short_channel_id"))) TS_LDKEvent_ProbeFailed_get_short_channel_id(uint64_t ptr) {
2737 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2738 assert(obj->tag == LDKEvent_ProbeFailed);
2739 uint64_t short_channel_id_ref = tag_ptr(&obj->probe_failed.short_channel_id, false);
2740 return short_channel_id_ref;
2742 int64_t __attribute__((export_name("TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable"))) TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(uint64_t ptr) {
2743 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2744 assert(obj->tag == LDKEvent_PendingHTLCsForwardable);
2745 int64_t time_forwardable_conv = obj->pending_htl_cs_forwardable.time_forwardable;
2746 return time_forwardable_conv;
2748 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_intercept_id"))) TS_LDKEvent_HTLCIntercepted_get_intercept_id(uint64_t ptr) {
2749 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2750 assert(obj->tag == LDKEvent_HTLCIntercepted);
2751 int8_tArray intercept_id_arr = init_int8_tArray(32, __LINE__);
2752 memcpy(intercept_id_arr->elems, obj->htlc_intercepted.intercept_id.data, 32);
2753 return intercept_id_arr;
2755 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid"))) TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(uint64_t ptr) {
2756 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2757 assert(obj->tag == LDKEvent_HTLCIntercepted);
2758 int64_t requested_next_hop_scid_conv = obj->htlc_intercepted.requested_next_hop_scid;
2759 return requested_next_hop_scid_conv;
2761 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_payment_hash"))) TS_LDKEvent_HTLCIntercepted_get_payment_hash(uint64_t ptr) {
2762 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2763 assert(obj->tag == LDKEvent_HTLCIntercepted);
2764 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2765 memcpy(payment_hash_arr->elems, obj->htlc_intercepted.payment_hash.data, 32);
2766 return payment_hash_arr;
2768 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(uint64_t ptr) {
2769 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2770 assert(obj->tag == LDKEvent_HTLCIntercepted);
2771 int64_t inbound_amount_msat_conv = obj->htlc_intercepted.inbound_amount_msat;
2772 return inbound_amount_msat_conv;
2774 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(uint64_t ptr) {
2775 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2776 assert(obj->tag == LDKEvent_HTLCIntercepted);
2777 int64_t expected_outbound_amount_msat_conv = obj->htlc_intercepted.expected_outbound_amount_msat;
2778 return expected_outbound_amount_msat_conv;
2780 uint64_tArray __attribute__((export_name("TS_LDKEvent_SpendableOutputs_get_outputs"))) TS_LDKEvent_SpendableOutputs_get_outputs(uint64_t ptr) {
2781 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2782 assert(obj->tag == LDKEvent_SpendableOutputs);
2783 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
2784 uint64_tArray outputs_arr = NULL;
2785 outputs_arr = init_uint64_tArray(outputs_var.datalen, __LINE__);
2786 uint64_t *outputs_arr_ptr = (uint64_t*)(((uint8_t*)outputs_arr) + 8);
2787 for (size_t b = 0; b < outputs_var.datalen; b++) {
2788 uint64_t outputs_conv_27_ref = tag_ptr(&outputs_var.data[b], false);
2789 outputs_arr_ptr[b] = outputs_conv_27_ref;
2794 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_prev_channel_id"))) TS_LDKEvent_PaymentForwarded_get_prev_channel_id(uint64_t ptr) {
2795 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2796 assert(obj->tag == LDKEvent_PaymentForwarded);
2797 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
2798 memcpy(prev_channel_id_arr->elems, obj->payment_forwarded.prev_channel_id.data, 32);
2799 return prev_channel_id_arr;
2801 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_next_channel_id"))) TS_LDKEvent_PaymentForwarded_get_next_channel_id(uint64_t ptr) {
2802 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2803 assert(obj->tag == LDKEvent_PaymentForwarded);
2804 int8_tArray next_channel_id_arr = init_int8_tArray(32, __LINE__);
2805 memcpy(next_channel_id_arr->elems, obj->payment_forwarded.next_channel_id.data, 32);
2806 return next_channel_id_arr;
2808 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_fee_earned_msat"))) TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(uint64_t ptr) {
2809 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2810 assert(obj->tag == LDKEvent_PaymentForwarded);
2811 uint64_t fee_earned_msat_ref = tag_ptr(&obj->payment_forwarded.fee_earned_msat, false);
2812 return fee_earned_msat_ref;
2814 jboolean __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx"))) TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(uint64_t ptr) {
2815 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2816 assert(obj->tag == LDKEvent_PaymentForwarded);
2817 jboolean claim_from_onchain_tx_conv = obj->payment_forwarded.claim_from_onchain_tx;
2818 return claim_from_onchain_tx_conv;
2820 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat"))) TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(uint64_t ptr) {
2821 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2822 assert(obj->tag == LDKEvent_PaymentForwarded);
2823 uint64_t outbound_amount_forwarded_msat_ref = tag_ptr(&obj->payment_forwarded.outbound_amount_forwarded_msat, false);
2824 return outbound_amount_forwarded_msat_ref;
2826 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_channel_id"))) TS_LDKEvent_ChannelPending_get_channel_id(uint64_t ptr) {
2827 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2828 assert(obj->tag == LDKEvent_ChannelPending);
2829 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2830 memcpy(channel_id_arr->elems, obj->channel_pending.channel_id.data, 32);
2831 return channel_id_arr;
2833 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_user_channel_id"))) TS_LDKEvent_ChannelPending_get_user_channel_id(uint64_t ptr) {
2834 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2835 assert(obj->tag == LDKEvent_ChannelPending);
2836 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2837 memcpy(user_channel_id_arr->elems, obj->channel_pending.user_channel_id.le_bytes, 16);
2838 return user_channel_id_arr;
2840 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_former_temporary_channel_id"))) TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(uint64_t ptr) {
2841 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2842 assert(obj->tag == LDKEvent_ChannelPending);
2843 int8_tArray former_temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2844 memcpy(former_temporary_channel_id_arr->elems, obj->channel_pending.former_temporary_channel_id.data, 32);
2845 return former_temporary_channel_id_arr;
2847 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_counterparty_node_id"))) TS_LDKEvent_ChannelPending_get_counterparty_node_id(uint64_t ptr) {
2848 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2849 assert(obj->tag == LDKEvent_ChannelPending);
2850 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2851 memcpy(counterparty_node_id_arr->elems, obj->channel_pending.counterparty_node_id.compressed_form, 33);
2852 return counterparty_node_id_arr;
2854 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelPending_get_funding_txo"))) TS_LDKEvent_ChannelPending_get_funding_txo(uint64_t ptr) {
2855 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2856 assert(obj->tag == LDKEvent_ChannelPending);
2857 LDKOutPoint funding_txo_var = obj->channel_pending.funding_txo;
2858 uint64_t funding_txo_ref = 0;
2859 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
2860 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
2861 return funding_txo_ref;
2863 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_id"))) TS_LDKEvent_ChannelReady_get_channel_id(uint64_t ptr) {
2864 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2865 assert(obj->tag == LDKEvent_ChannelReady);
2866 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2867 memcpy(channel_id_arr->elems, obj->channel_ready.channel_id.data, 32);
2868 return channel_id_arr;
2870 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_user_channel_id"))) TS_LDKEvent_ChannelReady_get_user_channel_id(uint64_t ptr) {
2871 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2872 assert(obj->tag == LDKEvent_ChannelReady);
2873 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2874 memcpy(user_channel_id_arr->elems, obj->channel_ready.user_channel_id.le_bytes, 16);
2875 return user_channel_id_arr;
2877 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_counterparty_node_id"))) TS_LDKEvent_ChannelReady_get_counterparty_node_id(uint64_t ptr) {
2878 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2879 assert(obj->tag == LDKEvent_ChannelReady);
2880 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2881 memcpy(counterparty_node_id_arr->elems, obj->channel_ready.counterparty_node_id.compressed_form, 33);
2882 return counterparty_node_id_arr;
2884 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_type"))) TS_LDKEvent_ChannelReady_get_channel_type(uint64_t ptr) {
2885 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2886 assert(obj->tag == LDKEvent_ChannelReady);
2887 LDKChannelTypeFeatures channel_type_var = obj->channel_ready.channel_type;
2888 uint64_t channel_type_ref = 0;
2889 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2890 channel_type_ref = tag_ptr(channel_type_var.inner, false);
2891 return channel_type_ref;
2893 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_channel_id"))) TS_LDKEvent_ChannelClosed_get_channel_id(uint64_t ptr) {
2894 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2895 assert(obj->tag == LDKEvent_ChannelClosed);
2896 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2897 memcpy(channel_id_arr->elems, obj->channel_closed.channel_id.data, 32);
2898 return channel_id_arr;
2900 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_user_channel_id"))) TS_LDKEvent_ChannelClosed_get_user_channel_id(uint64_t ptr) {
2901 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2902 assert(obj->tag == LDKEvent_ChannelClosed);
2903 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2904 memcpy(user_channel_id_arr->elems, obj->channel_closed.user_channel_id.le_bytes, 16);
2905 return user_channel_id_arr;
2907 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_reason"))) TS_LDKEvent_ChannelClosed_get_reason(uint64_t ptr) {
2908 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2909 assert(obj->tag == LDKEvent_ChannelClosed);
2910 uint64_t reason_ref = tag_ptr(&obj->channel_closed.reason, false);
2913 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_channel_id"))) TS_LDKEvent_DiscardFunding_get_channel_id(uint64_t ptr) {
2914 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2915 assert(obj->tag == LDKEvent_DiscardFunding);
2916 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2917 memcpy(channel_id_arr->elems, obj->discard_funding.channel_id.data, 32);
2918 return channel_id_arr;
2920 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_transaction"))) TS_LDKEvent_DiscardFunding_get_transaction(uint64_t ptr) {
2921 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2922 assert(obj->tag == LDKEvent_DiscardFunding);
2923 LDKTransaction transaction_var = obj->discard_funding.transaction;
2924 int8_tArray transaction_arr = init_int8_tArray(transaction_var.datalen, __LINE__);
2925 memcpy(transaction_arr->elems, transaction_var.data, transaction_var.datalen);
2926 return transaction_arr;
2928 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id"))) TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(uint64_t ptr) {
2929 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2930 assert(obj->tag == LDKEvent_OpenChannelRequest);
2931 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2932 memcpy(temporary_channel_id_arr->elems, obj->open_channel_request.temporary_channel_id.data, 32);
2933 return temporary_channel_id_arr;
2935 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id"))) TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(uint64_t ptr) {
2936 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2937 assert(obj->tag == LDKEvent_OpenChannelRequest);
2938 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2939 memcpy(counterparty_node_id_arr->elems, obj->open_channel_request.counterparty_node_id.compressed_form, 33);
2940 return counterparty_node_id_arr;
2942 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_funding_satoshis"))) TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(uint64_t ptr) {
2943 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2944 assert(obj->tag == LDKEvent_OpenChannelRequest);
2945 int64_t funding_satoshis_conv = obj->open_channel_request.funding_satoshis;
2946 return funding_satoshis_conv;
2948 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_push_msat"))) TS_LDKEvent_OpenChannelRequest_get_push_msat(uint64_t ptr) {
2949 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2950 assert(obj->tag == LDKEvent_OpenChannelRequest);
2951 int64_t push_msat_conv = obj->open_channel_request.push_msat;
2952 return push_msat_conv;
2954 uint64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_channel_type"))) TS_LDKEvent_OpenChannelRequest_get_channel_type(uint64_t ptr) {
2955 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2956 assert(obj->tag == LDKEvent_OpenChannelRequest);
2957 LDKChannelTypeFeatures channel_type_var = obj->open_channel_request.channel_type;
2958 uint64_t channel_type_ref = 0;
2959 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2960 channel_type_ref = tag_ptr(channel_type_var.inner, false);
2961 return channel_type_ref;
2963 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id"))) TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(uint64_t ptr) {
2964 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2965 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2966 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
2967 memcpy(prev_channel_id_arr->elems, obj->htlc_handling_failed.prev_channel_id.data, 32);
2968 return prev_channel_id_arr;
2970 uint64_t __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination"))) TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(uint64_t ptr) {
2971 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2972 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2973 uint64_t failed_next_destination_ref = tag_ptr(&obj->htlc_handling_failed.failed_next_destination, false);
2974 return failed_next_destination_ref;
2976 uint32_t __attribute__((export_name("TS_LDKCOption_EventZ_ty_from_ptr"))) TS_LDKCOption_EventZ_ty_from_ptr(uint64_t ptr) {
2977 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
2979 case LDKCOption_EventZ_Some: return 0;
2980 case LDKCOption_EventZ_None: return 1;
2984 uint64_t __attribute__((export_name("TS_LDKCOption_EventZ_Some_get_some"))) TS_LDKCOption_EventZ_Some_get_some(uint64_t ptr) {
2985 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
2986 assert(obj->tag == LDKCOption_EventZ_Some);
2987 uint64_t some_ref = tag_ptr(&obj->some, false);
2990 static inline struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
2991 CHECK(owner->result_ok);
2992 return COption_EventZ_clone(&*owner->contents.result);
2994 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_ok"))) TS_CResult_COption_EventZDecodeErrorZ_get_ok(uint64_t owner) {
2995 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
2996 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
2997 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_ok(owner_conv);
2998 uint64_t ret_ref = tag_ptr(ret_copy, true);
3002 static inline struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
3003 CHECK(!owner->result_ok);
3004 return DecodeError_clone(&*owner->contents.err);
3006 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_err"))) TS_CResult_COption_EventZDecodeErrorZ_get_err(uint64_t owner) {
3007 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
3008 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3009 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_err(owner_conv);
3010 uint64_t ret_ref = tag_ptr(ret_copy, true);
3014 uint32_t __attribute__((export_name("TS_LDKErrorAction_ty_from_ptr"))) TS_LDKErrorAction_ty_from_ptr(uint64_t ptr) {
3015 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3017 case LDKErrorAction_DisconnectPeer: return 0;
3018 case LDKErrorAction_IgnoreError: return 1;
3019 case LDKErrorAction_IgnoreAndLog: return 2;
3020 case LDKErrorAction_IgnoreDuplicateGossip: return 3;
3021 case LDKErrorAction_SendErrorMessage: return 4;
3022 case LDKErrorAction_SendWarningMessage: return 5;
3026 uint64_t __attribute__((export_name("TS_LDKErrorAction_DisconnectPeer_get_msg"))) TS_LDKErrorAction_DisconnectPeer_get_msg(uint64_t ptr) {
3027 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3028 assert(obj->tag == LDKErrorAction_DisconnectPeer);
3029 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
3030 uint64_t msg_ref = 0;
3031 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3032 msg_ref = tag_ptr(msg_var.inner, false);
3035 uint32_t __attribute__((export_name("TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log"))) TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(uint64_t ptr) {
3036 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3037 assert(obj->tag == LDKErrorAction_IgnoreAndLog);
3038 uint32_t ignore_and_log_conv = LDKLevel_to_js(obj->ignore_and_log);
3039 return ignore_and_log_conv;
3041 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendErrorMessage_get_msg"))) TS_LDKErrorAction_SendErrorMessage_get_msg(uint64_t ptr) {
3042 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3043 assert(obj->tag == LDKErrorAction_SendErrorMessage);
3044 LDKErrorMessage msg_var = obj->send_error_message.msg;
3045 uint64_t msg_ref = 0;
3046 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3047 msg_ref = tag_ptr(msg_var.inner, false);
3050 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_msg"))) TS_LDKErrorAction_SendWarningMessage_get_msg(uint64_t ptr) {
3051 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3052 assert(obj->tag == LDKErrorAction_SendWarningMessage);
3053 LDKWarningMessage msg_var = obj->send_warning_message.msg;
3054 uint64_t msg_ref = 0;
3055 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3056 msg_ref = tag_ptr(msg_var.inner, false);
3059 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_log_level"))) TS_LDKErrorAction_SendWarningMessage_get_log_level(uint64_t ptr) {
3060 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3061 assert(obj->tag == LDKErrorAction_SendWarningMessage);
3062 uint32_t log_level_conv = LDKLevel_to_js(obj->send_warning_message.log_level);
3063 return log_level_conv;
3065 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_ty_from_ptr"))) TS_LDKMessageSendEvent_ty_from_ptr(uint64_t ptr) {
3066 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3068 case LDKMessageSendEvent_SendAcceptChannel: return 0;
3069 case LDKMessageSendEvent_SendOpenChannel: return 1;
3070 case LDKMessageSendEvent_SendFundingCreated: return 2;
3071 case LDKMessageSendEvent_SendFundingSigned: return 3;
3072 case LDKMessageSendEvent_SendChannelReady: return 4;
3073 case LDKMessageSendEvent_SendAnnouncementSignatures: return 5;
3074 case LDKMessageSendEvent_UpdateHTLCs: return 6;
3075 case LDKMessageSendEvent_SendRevokeAndACK: return 7;
3076 case LDKMessageSendEvent_SendClosingSigned: return 8;
3077 case LDKMessageSendEvent_SendShutdown: return 9;
3078 case LDKMessageSendEvent_SendChannelReestablish: return 10;
3079 case LDKMessageSendEvent_SendChannelAnnouncement: return 11;
3080 case LDKMessageSendEvent_BroadcastChannelAnnouncement: return 12;
3081 case LDKMessageSendEvent_BroadcastChannelUpdate: return 13;
3082 case LDKMessageSendEvent_BroadcastNodeAnnouncement: return 14;
3083 case LDKMessageSendEvent_SendChannelUpdate: return 15;
3084 case LDKMessageSendEvent_HandleError: return 16;
3085 case LDKMessageSendEvent_SendChannelRangeQuery: return 17;
3086 case LDKMessageSendEvent_SendShortIdsQuery: return 18;
3087 case LDKMessageSendEvent_SendReplyChannelRange: return 19;
3088 case LDKMessageSendEvent_SendGossipTimestampFilter: return 20;
3092 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(uint64_t ptr) {
3093 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3094 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
3095 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3096 memcpy(node_id_arr->elems, obj->send_accept_channel.node_id.compressed_form, 33);
3099 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_msg"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(uint64_t ptr) {
3100 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3101 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
3102 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
3103 uint64_t msg_ref = 0;
3104 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3105 msg_ref = tag_ptr(msg_var.inner, false);
3108 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_node_id"))) TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(uint64_t ptr) {
3109 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3110 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
3111 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3112 memcpy(node_id_arr->elems, obj->send_open_channel.node_id.compressed_form, 33);
3115 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_msg"))) TS_LDKMessageSendEvent_SendOpenChannel_get_msg(uint64_t ptr) {
3116 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3117 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
3118 LDKOpenChannel msg_var = obj->send_open_channel.msg;
3119 uint64_t msg_ref = 0;
3120 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3121 msg_ref = tag_ptr(msg_var.inner, false);
3124 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_node_id"))) TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(uint64_t ptr) {
3125 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3126 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
3127 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3128 memcpy(node_id_arr->elems, obj->send_funding_created.node_id.compressed_form, 33);
3131 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_msg"))) TS_LDKMessageSendEvent_SendFundingCreated_get_msg(uint64_t ptr) {
3132 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3133 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
3134 LDKFundingCreated msg_var = obj->send_funding_created.msg;
3135 uint64_t msg_ref = 0;
3136 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3137 msg_ref = tag_ptr(msg_var.inner, false);
3140 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(uint64_t ptr) {
3141 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3142 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
3143 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3144 memcpy(node_id_arr->elems, obj->send_funding_signed.node_id.compressed_form, 33);
3147 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_msg"))) TS_LDKMessageSendEvent_SendFundingSigned_get_msg(uint64_t ptr) {
3148 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3149 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
3150 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
3151 uint64_t msg_ref = 0;
3152 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3153 msg_ref = tag_ptr(msg_var.inner, false);
3156 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReady_get_node_id(uint64_t ptr) {
3157 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3158 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
3159 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3160 memcpy(node_id_arr->elems, obj->send_channel_ready.node_id.compressed_form, 33);
3163 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_msg"))) TS_LDKMessageSendEvent_SendChannelReady_get_msg(uint64_t ptr) {
3164 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3165 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
3166 LDKChannelReady msg_var = obj->send_channel_ready.msg;
3167 uint64_t msg_ref = 0;
3168 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3169 msg_ref = tag_ptr(msg_var.inner, false);
3172 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(uint64_t ptr) {
3173 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3174 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
3175 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3176 memcpy(node_id_arr->elems, obj->send_announcement_signatures.node_id.compressed_form, 33);
3179 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(uint64_t ptr) {
3180 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3181 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
3182 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
3183 uint64_t msg_ref = 0;
3184 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3185 msg_ref = tag_ptr(msg_var.inner, false);
3188 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(uint64_t ptr) {
3189 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3190 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
3191 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3192 memcpy(node_id_arr->elems, obj->update_htl_cs.node_id.compressed_form, 33);
3195 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_updates"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(uint64_t ptr) {
3196 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3197 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
3198 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
3199 uint64_t updates_ref = 0;
3200 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
3201 updates_ref = tag_ptr(updates_var.inner, false);
3204 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(uint64_t ptr) {
3205 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3206 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
3207 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3208 memcpy(node_id_arr->elems, obj->send_revoke_and_ack.node_id.compressed_form, 33);
3211 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(uint64_t ptr) {
3212 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3213 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
3214 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
3215 uint64_t msg_ref = 0;
3216 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3217 msg_ref = tag_ptr(msg_var.inner, false);
3220 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(uint64_t ptr) {
3221 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3222 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
3223 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3224 memcpy(node_id_arr->elems, obj->send_closing_signed.node_id.compressed_form, 33);
3227 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_msg"))) TS_LDKMessageSendEvent_SendClosingSigned_get_msg(uint64_t ptr) {
3228 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3229 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
3230 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
3231 uint64_t msg_ref = 0;
3232 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3233 msg_ref = tag_ptr(msg_var.inner, false);
3236 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_node_id"))) TS_LDKMessageSendEvent_SendShutdown_get_node_id(uint64_t ptr) {
3237 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3238 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
3239 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3240 memcpy(node_id_arr->elems, obj->send_shutdown.node_id.compressed_form, 33);
3243 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_msg"))) TS_LDKMessageSendEvent_SendShutdown_get_msg(uint64_t ptr) {
3244 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3245 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
3246 LDKShutdown msg_var = obj->send_shutdown.msg;
3247 uint64_t msg_ref = 0;
3248 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3249 msg_ref = tag_ptr(msg_var.inner, false);
3252 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(uint64_t ptr) {
3253 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3254 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
3255 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3256 memcpy(node_id_arr->elems, obj->send_channel_reestablish.node_id.compressed_form, 33);
3259 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_msg"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(uint64_t ptr) {
3260 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3261 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
3262 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
3263 uint64_t msg_ref = 0;
3264 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3265 msg_ref = tag_ptr(msg_var.inner, false);
3268 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(uint64_t ptr) {
3269 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3270 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3271 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3272 memcpy(node_id_arr->elems, obj->send_channel_announcement.node_id.compressed_form, 33);
3275 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(uint64_t ptr) {
3276 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3277 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3278 LDKChannelAnnouncement msg_var = obj->send_channel_announcement.msg;
3279 uint64_t msg_ref = 0;
3280 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3281 msg_ref = tag_ptr(msg_var.inner, false);
3284 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(uint64_t ptr) {
3285 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3286 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3287 LDKChannelUpdate update_msg_var = obj->send_channel_announcement.update_msg;
3288 uint64_t update_msg_ref = 0;
3289 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
3290 update_msg_ref = tag_ptr(update_msg_var.inner, false);
3291 return update_msg_ref;
3293 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(uint64_t ptr) {
3294 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3295 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
3296 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
3297 uint64_t msg_ref = 0;
3298 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3299 msg_ref = tag_ptr(msg_var.inner, false);
3302 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(uint64_t ptr) {
3303 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3304 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
3305 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
3306 uint64_t update_msg_ref = 0;
3307 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
3308 update_msg_ref = tag_ptr(update_msg_var.inner, false);
3309 return update_msg_ref;
3311 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(uint64_t ptr) {
3312 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3313 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelUpdate);
3314 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
3315 uint64_t msg_ref = 0;
3316 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3317 msg_ref = tag_ptr(msg_var.inner, false);
3320 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(uint64_t ptr) {
3321 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3322 assert(obj->tag == LDKMessageSendEvent_BroadcastNodeAnnouncement);
3323 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
3324 uint64_t msg_ref = 0;
3325 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3326 msg_ref = tag_ptr(msg_var.inner, false);
3329 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(uint64_t ptr) {
3330 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3331 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
3332 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3333 memcpy(node_id_arr->elems, obj->send_channel_update.node_id.compressed_form, 33);
3336 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(uint64_t ptr) {
3337 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3338 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
3339 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
3340 uint64_t msg_ref = 0;
3341 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3342 msg_ref = tag_ptr(msg_var.inner, false);
3345 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_node_id"))) TS_LDKMessageSendEvent_HandleError_get_node_id(uint64_t ptr) {
3346 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3347 assert(obj->tag == LDKMessageSendEvent_HandleError);
3348 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3349 memcpy(node_id_arr->elems, obj->handle_error.node_id.compressed_form, 33);
3352 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_action"))) TS_LDKMessageSendEvent_HandleError_get_action(uint64_t ptr) {
3353 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3354 assert(obj->tag == LDKMessageSendEvent_HandleError);
3355 uint64_t action_ref = tag_ptr(&obj->handle_error.action, false);
3358 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(uint64_t ptr) {
3359 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3360 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
3361 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3362 memcpy(node_id_arr->elems, obj->send_channel_range_query.node_id.compressed_form, 33);
3365 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(uint64_t ptr) {
3366 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3367 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
3368 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
3369 uint64_t msg_ref = 0;
3370 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3371 msg_ref = tag_ptr(msg_var.inner, false);
3374 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(uint64_t ptr) {
3375 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3376 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
3377 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3378 memcpy(node_id_arr->elems, obj->send_short_ids_query.node_id.compressed_form, 33);
3381 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(uint64_t ptr) {
3382 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3383 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
3384 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
3385 uint64_t msg_ref = 0;
3386 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3387 msg_ref = tag_ptr(msg_var.inner, false);
3390 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(uint64_t ptr) {
3391 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3392 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
3393 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3394 memcpy(node_id_arr->elems, obj->send_reply_channel_range.node_id.compressed_form, 33);
3397 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(uint64_t ptr) {
3398 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3399 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
3400 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
3401 uint64_t msg_ref = 0;
3402 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3403 msg_ref = tag_ptr(msg_var.inner, false);
3406 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(uint64_t ptr) {
3407 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3408 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
3409 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3410 memcpy(node_id_arr->elems, obj->send_gossip_timestamp_filter.node_id.compressed_form, 33);
3413 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(uint64_t ptr) {
3414 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3415 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
3416 LDKGossipTimestampFilter msg_var = obj->send_gossip_timestamp_filter.msg;
3417 uint64_t msg_ref = 0;
3418 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3419 msg_ref = tag_ptr(msg_var.inner, false);
3422 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
3423 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
3424 for (size_t i = 0; i < ret.datalen; i++) {
3425 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
3429 static inline LDKCVec_ChainHashZ CVec_ChainHashZ_clone(const LDKCVec_ChainHashZ *orig) {
3430 LDKCVec_ChainHashZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ChainHashZ clone bytes"), .datalen = orig->datalen };
3431 for (size_t i = 0; i < ret.datalen; i++) {
3432 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
3436 static inline struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
3437 CHECK(owner->result_ok);
3438 return *owner->contents.result;
3440 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_ok"))) TS_CResult_PublicKeyErrorZ_get_ok(uint64_t owner) {
3441 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(owner);
3442 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
3443 memcpy(ret_arr->elems, CResult_PublicKeyErrorZ_get_ok(owner_conv).compressed_form, 33);
3447 static inline enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
3448 CHECK(!owner->result_ok);
3449 return *owner->contents.err;
3451 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_err"))) TS_CResult_PublicKeyErrorZ_get_err(uint64_t owner) {
3452 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(owner);
3453 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PublicKeyErrorZ_get_err(owner_conv));
3457 static inline struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3458 LDKNodeId ret = *owner->contents.result;
3459 ret.is_owned = false;
3462 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_ok"))) TS_CResult_NodeIdDecodeErrorZ_get_ok(uint64_t owner) {
3463 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3464 LDKNodeId ret_var = CResult_NodeIdDecodeErrorZ_get_ok(owner_conv);
3465 uint64_t ret_ref = 0;
3466 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3467 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3471 static inline struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3472 CHECK(!owner->result_ok);
3473 return DecodeError_clone(&*owner->contents.err);
3475 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_err"))) TS_CResult_NodeIdDecodeErrorZ_get_err(uint64_t owner) {
3476 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3477 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3478 *ret_copy = CResult_NodeIdDecodeErrorZ_get_err(owner_conv);
3479 uint64_t ret_ref = tag_ptr(ret_copy, true);
3483 static inline struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3484 CHECK(owner->result_ok);
3485 return COption_NetworkUpdateZ_clone(&*owner->contents.result);
3487 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint64_t owner) {
3488 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3489 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
3490 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner_conv);
3491 uint64_t ret_ref = tag_ptr(ret_copy, true);
3495 static inline struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3496 CHECK(!owner->result_ok);
3497 return DecodeError_clone(&*owner->contents.err);
3499 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint64_t owner) {
3500 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3501 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3502 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner_conv);
3503 uint64_t ret_ref = tag_ptr(ret_copy, true);
3507 static inline struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner){
3508 CHECK(owner->result_ok);
3509 return TxOut_clone(&*owner->contents.result);
3511 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_get_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_get_ok(uint64_t owner) {
3512 LDKCResult_TxOutUtxoLookupErrorZ* owner_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(owner);
3513 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
3514 *ret_ref = CResult_TxOutUtxoLookupErrorZ_get_ok(owner_conv);
3515 return tag_ptr(ret_ref, true);
3518 static inline enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner){
3519 CHECK(!owner->result_ok);
3520 return UtxoLookupError_clone(&*owner->contents.err);
3522 uint32_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_get_err"))) TS_CResult_TxOutUtxoLookupErrorZ_get_err(uint64_t owner) {
3523 LDKCResult_TxOutUtxoLookupErrorZ* owner_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(owner);
3524 uint32_t ret_conv = LDKUtxoLookupError_to_js(CResult_TxOutUtxoLookupErrorZ_get_err(owner_conv));
3528 uint32_t __attribute__((export_name("TS_LDKUtxoResult_ty_from_ptr"))) TS_LDKUtxoResult_ty_from_ptr(uint64_t ptr) {
3529 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3531 case LDKUtxoResult_Sync: return 0;
3532 case LDKUtxoResult_Async: return 1;
3536 uint64_t __attribute__((export_name("TS_LDKUtxoResult_Sync_get_sync"))) TS_LDKUtxoResult_Sync_get_sync(uint64_t ptr) {
3537 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3538 assert(obj->tag == LDKUtxoResult_Sync);
3539 LDKCResult_TxOutUtxoLookupErrorZ* sync_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
3540 *sync_conv = obj->sync;
3541 *sync_conv = CResult_TxOutUtxoLookupErrorZ_clone(sync_conv);
3542 return tag_ptr(sync_conv, true);
3544 uint64_t __attribute__((export_name("TS_LDKUtxoResult_Async_get_async"))) TS_LDKUtxoResult_Async_get_async(uint64_t ptr) {
3545 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3546 assert(obj->tag == LDKUtxoResult_Async);
3547 LDKUtxoFuture async_var = obj->async;
3548 uint64_t async_ref = 0;
3549 CHECK_INNER_FIELD_ACCESS_OR_NULL(async_var);
3550 async_ref = tag_ptr(async_var.inner, false);
3553 typedef struct LDKUtxoLookup_JCalls {
3554 atomic_size_t refcnt;
3555 uint32_t instance_ptr;
3556 } LDKUtxoLookup_JCalls;
3557 static void LDKUtxoLookup_JCalls_free(void* this_arg) {
3558 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) this_arg;
3559 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3563 LDKUtxoResult get_utxo_LDKUtxoLookup_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
3564 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) this_arg;
3565 int8_tArray genesis_hash_arr = init_int8_tArray(32, __LINE__);
3566 memcpy(genesis_hash_arr->elems, *genesis_hash, 32);
3567 int64_t short_channel_id_conv = short_channel_id;
3568 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);
3569 void* ret_ptr = untag_ptr(ret);
3570 CHECK_ACCESS(ret_ptr);
3571 LDKUtxoResult ret_conv = *(LDKUtxoResult*)(ret_ptr);
3572 FREE(untag_ptr(ret));
3575 static void LDKUtxoLookup_JCalls_cloned(LDKUtxoLookup* new_obj) {
3576 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) new_obj->this_arg;
3577 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3579 static inline LDKUtxoLookup LDKUtxoLookup_init (JSValue o) {
3580 LDKUtxoLookup_JCalls *calls = MALLOC(sizeof(LDKUtxoLookup_JCalls), "LDKUtxoLookup_JCalls");
3581 atomic_init(&calls->refcnt, 1);
3582 calls->instance_ptr = o;
3584 LDKUtxoLookup ret = {
3585 .this_arg = (void*) calls,
3586 .get_utxo = get_utxo_LDKUtxoLookup_jcall,
3587 .free = LDKUtxoLookup_JCalls_free,
3591 uint64_t __attribute__((export_name("TS_LDKUtxoLookup_new"))) TS_LDKUtxoLookup_new(JSValue o) {
3592 LDKUtxoLookup *res_ptr = MALLOC(sizeof(LDKUtxoLookup), "LDKUtxoLookup");
3593 *res_ptr = LDKUtxoLookup_init(o);
3594 return tag_ptr(res_ptr, true);
3596 uint64_t __attribute__((export_name("TS_UtxoLookup_get_utxo"))) TS_UtxoLookup_get_utxo(uint64_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) {
3597 void* this_arg_ptr = untag_ptr(this_arg);
3598 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
3599 LDKUtxoLookup* this_arg_conv = (LDKUtxoLookup*)this_arg_ptr;
3600 uint8_t genesis_hash_arr[32];
3601 CHECK(genesis_hash->arr_len == 32);
3602 memcpy(genesis_hash_arr, genesis_hash->elems, 32); FREE(genesis_hash);
3603 uint8_t (*genesis_hash_ref)[32] = &genesis_hash_arr;
3604 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
3605 *ret_copy = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
3606 uint64_t ret_ref = tag_ptr(ret_copy, true);
3610 uint32_t __attribute__((export_name("TS_LDKCOption_UtxoLookupZ_ty_from_ptr"))) TS_LDKCOption_UtxoLookupZ_ty_from_ptr(uint64_t ptr) {
3611 LDKCOption_UtxoLookupZ *obj = (LDKCOption_UtxoLookupZ*)untag_ptr(ptr);
3613 case LDKCOption_UtxoLookupZ_Some: return 0;
3614 case LDKCOption_UtxoLookupZ_None: return 1;
3618 uint64_t __attribute__((export_name("TS_LDKCOption_UtxoLookupZ_Some_get_some"))) TS_LDKCOption_UtxoLookupZ_Some_get_some(uint64_t ptr) {
3619 LDKCOption_UtxoLookupZ *obj = (LDKCOption_UtxoLookupZ*)untag_ptr(ptr);
3620 assert(obj->tag == LDKCOption_UtxoLookupZ_Some);
3621 LDKUtxoLookup* some_ret = MALLOC(sizeof(LDKUtxoLookup), "LDKUtxoLookup");
3622 *some_ret = obj->some;
3623 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
3624 if ((*some_ret).free == LDKUtxoLookup_JCalls_free) {
3625 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
3626 LDKUtxoLookup_JCalls_cloned(&(*some_ret));
3628 return tag_ptr(some_ret, true);
3630 static inline bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3631 CHECK(owner->result_ok);
3632 return *owner->contents.result;
3634 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_ok"))) TS_CResult_boolLightningErrorZ_get_ok(uint64_t owner) {
3635 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3636 jboolean ret_conv = CResult_boolLightningErrorZ_get_ok(owner_conv);
3640 static inline struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3641 LDKLightningError ret = *owner->contents.err;
3642 ret.is_owned = false;
3645 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_err"))) TS_CResult_boolLightningErrorZ_get_err(uint64_t owner) {
3646 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3647 LDKLightningError ret_var = CResult_boolLightningErrorZ_get_err(owner_conv);
3648 uint64_t ret_ref = 0;
3649 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3650 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3654 static inline struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3655 LDKChannelAnnouncement ret = owner->a;
3656 ret.is_owned = false;
3659 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint64_t owner) {
3660 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3661 LDKChannelAnnouncement ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner_conv);
3662 uint64_t ret_ref = 0;
3663 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3664 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3668 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3669 LDKChannelUpdate ret = owner->b;
3670 ret.is_owned = false;
3673 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint64_t owner) {
3674 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3675 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner_conv);
3676 uint64_t ret_ref = 0;
3677 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3678 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3682 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3683 LDKChannelUpdate ret = owner->c;
3684 ret.is_owned = false;
3687 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint64_t owner) {
3688 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3689 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner_conv);
3690 uint64_t ret_ref = 0;
3691 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3692 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3696 uint32_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(uint64_t ptr) {
3697 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3699 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some: return 0;
3700 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None: return 1;
3704 uint64_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(uint64_t ptr) {
3705 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3706 assert(obj->tag == LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some);
3707 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* some_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
3708 *some_conv = obj->some;
3709 *some_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(some_conv);
3710 return tag_ptr(some_conv, true);
3712 static inline void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3713 CHECK(owner->result_ok);
3714 return *owner->contents.result;
3716 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_ok"))) TS_CResult_NoneLightningErrorZ_get_ok(uint64_t owner) {
3717 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3718 CResult_NoneLightningErrorZ_get_ok(owner_conv);
3721 static inline struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3722 LDKLightningError ret = *owner->contents.err;
3723 ret.is_owned = false;
3726 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_err"))) TS_CResult_NoneLightningErrorZ_get_err(uint64_t owner) {
3727 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3728 LDKLightningError ret_var = CResult_NoneLightningErrorZ_get_err(owner_conv);
3729 uint64_t ret_ref = 0;
3730 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3731 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3735 static inline struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3736 LDKChannelUpdateInfo ret = *owner->contents.result;
3737 ret.is_owned = false;
3740 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(uint64_t owner) {
3741 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
3742 LDKChannelUpdateInfo ret_var = CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner_conv);
3743 uint64_t ret_ref = 0;
3744 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3745 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3749 static inline struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3750 CHECK(!owner->result_ok);
3751 return DecodeError_clone(&*owner->contents.err);
3753 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(uint64_t owner) {
3754 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
3755 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3756 *ret_copy = CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner_conv);
3757 uint64_t ret_ref = tag_ptr(ret_copy, true);
3761 static inline struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3762 LDKChannelInfo ret = *owner->contents.result;
3763 ret.is_owned = false;
3766 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_get_ok(uint64_t owner) {
3767 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
3768 LDKChannelInfo ret_var = CResult_ChannelInfoDecodeErrorZ_get_ok(owner_conv);
3769 uint64_t ret_ref = 0;
3770 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3771 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3775 static inline struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3776 CHECK(!owner->result_ok);
3777 return DecodeError_clone(&*owner->contents.err);
3779 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelInfoDecodeErrorZ_get_err(uint64_t owner) {
3780 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
3781 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3782 *ret_copy = CResult_ChannelInfoDecodeErrorZ_get_err(owner_conv);
3783 uint64_t ret_ref = tag_ptr(ret_copy, true);
3787 static inline struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3788 LDKRoutingFees ret = *owner->contents.result;
3789 ret.is_owned = false;
3792 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_get_ok(uint64_t owner) {
3793 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
3794 LDKRoutingFees ret_var = CResult_RoutingFeesDecodeErrorZ_get_ok(owner_conv);
3795 uint64_t ret_ref = 0;
3796 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3797 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3801 static inline struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3802 CHECK(!owner->result_ok);
3803 return DecodeError_clone(&*owner->contents.err);
3805 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_err"))) TS_CResult_RoutingFeesDecodeErrorZ_get_err(uint64_t owner) {
3806 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
3807 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3808 *ret_copy = CResult_RoutingFeesDecodeErrorZ_get_err(owner_conv);
3809 uint64_t ret_ref = tag_ptr(ret_copy, true);
3813 uint32_t __attribute__((export_name("TS_LDKNetAddress_ty_from_ptr"))) TS_LDKNetAddress_ty_from_ptr(uint64_t ptr) {
3814 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3816 case LDKNetAddress_IPv4: return 0;
3817 case LDKNetAddress_IPv6: return 1;
3818 case LDKNetAddress_OnionV2: return 2;
3819 case LDKNetAddress_OnionV3: return 3;
3820 case LDKNetAddress_Hostname: return 4;
3824 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv4_get_addr"))) TS_LDKNetAddress_IPv4_get_addr(uint64_t ptr) {
3825 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3826 assert(obj->tag == LDKNetAddress_IPv4);
3827 int8_tArray addr_arr = init_int8_tArray(4, __LINE__);
3828 memcpy(addr_arr->elems, obj->i_pv4.addr.data, 4);
3831 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv4_get_port"))) TS_LDKNetAddress_IPv4_get_port(uint64_t ptr) {
3832 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3833 assert(obj->tag == LDKNetAddress_IPv4);
3834 int16_t port_conv = obj->i_pv4.port;
3837 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv6_get_addr"))) TS_LDKNetAddress_IPv6_get_addr(uint64_t ptr) {
3838 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3839 assert(obj->tag == LDKNetAddress_IPv6);
3840 int8_tArray addr_arr = init_int8_tArray(16, __LINE__);
3841 memcpy(addr_arr->elems, obj->i_pv6.addr.data, 16);
3844 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv6_get_port"))) TS_LDKNetAddress_IPv6_get_port(uint64_t ptr) {
3845 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3846 assert(obj->tag == LDKNetAddress_IPv6);
3847 int16_t port_conv = obj->i_pv6.port;
3850 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV2_get_onion_v2"))) TS_LDKNetAddress_OnionV2_get_onion_v2(uint64_t ptr) {
3851 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3852 assert(obj->tag == LDKNetAddress_OnionV2);
3853 int8_tArray onion_v2_arr = init_int8_tArray(12, __LINE__);
3854 memcpy(onion_v2_arr->elems, obj->onion_v2.data, 12);
3855 return onion_v2_arr;
3857 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_ed25519_pubkey"))) TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(uint64_t ptr) {
3858 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3859 assert(obj->tag == LDKNetAddress_OnionV3);
3860 int8_tArray ed25519_pubkey_arr = init_int8_tArray(32, __LINE__);
3861 memcpy(ed25519_pubkey_arr->elems, obj->onion_v3.ed25519_pubkey.data, 32);
3862 return ed25519_pubkey_arr;
3864 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_checksum"))) TS_LDKNetAddress_OnionV3_get_checksum(uint64_t ptr) {
3865 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3866 assert(obj->tag == LDKNetAddress_OnionV3);
3867 int16_t checksum_conv = obj->onion_v3.checksum;
3868 return checksum_conv;
3870 int8_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_version"))) TS_LDKNetAddress_OnionV3_get_version(uint64_t ptr) {
3871 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3872 assert(obj->tag == LDKNetAddress_OnionV3);
3873 int8_t version_conv = obj->onion_v3.version;
3874 return version_conv;
3876 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_port"))) TS_LDKNetAddress_OnionV3_get_port(uint64_t ptr) {
3877 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3878 assert(obj->tag == LDKNetAddress_OnionV3);
3879 int16_t port_conv = obj->onion_v3.port;
3882 uint64_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_hostname"))) TS_LDKNetAddress_Hostname_get_hostname(uint64_t ptr) {
3883 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3884 assert(obj->tag == LDKNetAddress_Hostname);
3885 LDKHostname hostname_var = obj->hostname.hostname;
3886 uint64_t hostname_ref = 0;
3887 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_var);
3888 hostname_ref = tag_ptr(hostname_var.inner, false);
3889 return hostname_ref;
3891 int16_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_port"))) TS_LDKNetAddress_Hostname_get_port(uint64_t ptr) {
3892 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3893 assert(obj->tag == LDKNetAddress_Hostname);
3894 int16_t port_conv = obj->hostname.port;
3897 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
3898 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
3899 for (size_t i = 0; i < ret.datalen; i++) {
3900 ret.data[i] = NetAddress_clone(&orig->data[i]);
3904 static inline struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3905 LDKNodeAnnouncementInfo ret = *owner->contents.result;
3906 ret.is_owned = false;
3909 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint64_t owner) {
3910 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
3911 LDKNodeAnnouncementInfo ret_var = CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner_conv);
3912 uint64_t ret_ref = 0;
3913 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3914 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3918 static inline struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3919 CHECK(!owner->result_ok);
3920 return DecodeError_clone(&*owner->contents.err);
3922 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(uint64_t owner) {
3923 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
3924 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3925 *ret_copy = CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner_conv);
3926 uint64_t ret_ref = tag_ptr(ret_copy, true);
3930 static inline struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3931 LDKNodeAlias ret = *owner->contents.result;
3932 ret.is_owned = false;
3935 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_ok"))) TS_CResult_NodeAliasDecodeErrorZ_get_ok(uint64_t owner) {
3936 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
3937 LDKNodeAlias ret_var = CResult_NodeAliasDecodeErrorZ_get_ok(owner_conv);
3938 uint64_t ret_ref = 0;
3939 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3940 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3944 static inline struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3945 CHECK(!owner->result_ok);
3946 return DecodeError_clone(&*owner->contents.err);
3948 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_err"))) TS_CResult_NodeAliasDecodeErrorZ_get_err(uint64_t owner) {
3949 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
3950 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3951 *ret_copy = CResult_NodeAliasDecodeErrorZ_get_err(owner_conv);
3952 uint64_t ret_ref = tag_ptr(ret_copy, true);
3956 static inline struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3957 LDKNodeInfo ret = *owner->contents.result;
3958 ret.is_owned = false;
3961 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeInfoDecodeErrorZ_get_ok(uint64_t owner) {
3962 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
3963 LDKNodeInfo ret_var = CResult_NodeInfoDecodeErrorZ_get_ok(owner_conv);
3964 uint64_t ret_ref = 0;
3965 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3966 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3970 static inline struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3971 CHECK(!owner->result_ok);
3972 return DecodeError_clone(&*owner->contents.err);
3974 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_err"))) TS_CResult_NodeInfoDecodeErrorZ_get_err(uint64_t owner) {
3975 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
3976 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3977 *ret_copy = CResult_NodeInfoDecodeErrorZ_get_err(owner_conv);
3978 uint64_t ret_ref = tag_ptr(ret_copy, true);
3982 static inline struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3983 LDKNetworkGraph ret = *owner->contents.result;
3984 ret.is_owned = false;
3987 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_get_ok(uint64_t owner) {
3988 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
3989 LDKNetworkGraph ret_var = CResult_NetworkGraphDecodeErrorZ_get_ok(owner_conv);
3990 uint64_t ret_ref = 0;
3991 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3992 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3996 static inline struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3997 CHECK(!owner->result_ok);
3998 return DecodeError_clone(&*owner->contents.err);
4000 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_err"))) TS_CResult_NetworkGraphDecodeErrorZ_get_err(uint64_t owner) {
4001 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
4002 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4003 *ret_copy = CResult_NetworkGraphDecodeErrorZ_get_err(owner_conv);
4004 uint64_t ret_ref = tag_ptr(ret_copy, true);
4008 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr"))) TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(uint64_t ptr) {
4009 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(ptr);
4011 case LDKCOption_CVec_NetAddressZZ_Some: return 0;
4012 case LDKCOption_CVec_NetAddressZZ_None: return 1;
4016 uint64_tArray __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_Some_get_some"))) TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(uint64_t ptr) {
4017 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(ptr);
4018 assert(obj->tag == LDKCOption_CVec_NetAddressZZ_Some);
4019 LDKCVec_NetAddressZ some_var = obj->some;
4020 uint64_tArray some_arr = NULL;
4021 some_arr = init_uint64_tArray(some_var.datalen, __LINE__);
4022 uint64_t *some_arr_ptr = (uint64_t*)(((uint8_t*)some_arr) + 8);
4023 for (size_t m = 0; m < some_var.datalen; m++) {
4024 uint64_t some_conv_12_ref = tag_ptr(&some_var.data[m], false);
4025 some_arr_ptr[m] = some_conv_12_ref;
4030 static inline struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4031 LDKDelayedPaymentOutputDescriptor ret = *owner->contents.result;
4032 ret.is_owned = false;
4035 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4036 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4037 LDKDelayedPaymentOutputDescriptor ret_var = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
4038 uint64_t ret_ref = 0;
4039 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4040 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4044 static inline struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4045 CHECK(!owner->result_ok);
4046 return DecodeError_clone(&*owner->contents.err);
4048 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4049 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4050 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4051 *ret_copy = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
4052 uint64_t ret_ref = tag_ptr(ret_copy, true);
4056 static inline struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4057 LDKStaticPaymentOutputDescriptor ret = *owner->contents.result;
4058 ret.is_owned = false;
4061 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4062 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4063 LDKStaticPaymentOutputDescriptor ret_var = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
4064 uint64_t ret_ref = 0;
4065 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4066 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4070 static inline struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4071 CHECK(!owner->result_ok);
4072 return DecodeError_clone(&*owner->contents.err);
4074 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4075 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4076 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4077 *ret_copy = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
4078 uint64_t ret_ref = tag_ptr(ret_copy, true);
4082 static inline struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4083 CHECK(owner->result_ok);
4084 return SpendableOutputDescriptor_clone(&*owner->contents.result);
4086 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4087 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4088 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
4089 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
4090 uint64_t ret_ref = tag_ptr(ret_copy, true);
4094 static inline struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4095 CHECK(!owner->result_ok);
4096 return DecodeError_clone(&*owner->contents.err);
4098 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4099 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4100 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4101 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner_conv);
4102 uint64_t ret_ref = tag_ptr(ret_copy, true);
4106 static inline LDKCVec_PaymentPreimageZ CVec_PaymentPreimageZ_clone(const LDKCVec_PaymentPreimageZ *orig) {
4107 LDKCVec_PaymentPreimageZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_PaymentPreimageZ clone bytes"), .datalen = orig->datalen };
4108 for (size_t i = 0; i < ret.datalen; i++) {
4109 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
4113 static inline struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
4116 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_a"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(uint64_t owner) {
4117 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(owner);
4118 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
4119 memcpy(ret_arr->elems, C2Tuple_SignatureCVec_SignatureZZ_get_a(owner_conv).compact_form, 64);
4123 static inline struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
4126 ptrArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_b"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(uint64_t owner) {
4127 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(owner);
4128 LDKCVec_SignatureZ ret_var = C2Tuple_SignatureCVec_SignatureZZ_get_b(owner_conv);
4129 ptrArray ret_arr = NULL;
4130 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
4131 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
4132 for (size_t m = 0; m < ret_var.datalen; m++) {
4133 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
4134 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
4135 ret_arr_ptr[m] = ret_conv_12_arr;
4141 static inline struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
4142 CHECK(owner->result_ok);
4143 return C2Tuple_SignatureCVec_SignatureZZ_clone(&*owner->contents.result);
4145 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint64_t owner) {
4146 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(owner);
4147 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
4148 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner_conv);
4149 return tag_ptr(ret_conv, true);
4152 static inline void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
4153 CHECK(!owner->result_ok);
4154 return *owner->contents.err;
4156 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(uint64_t owner) {
4157 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(owner);
4158 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner_conv);
4161 static inline struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
4162 CHECK(owner->result_ok);
4163 return *owner->contents.result;
4165 int8_tArray __attribute__((export_name("TS_CResult_SignatureNoneZ_get_ok"))) TS_CResult_SignatureNoneZ_get_ok(uint64_t owner) {
4166 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(owner);
4167 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
4168 memcpy(ret_arr->elems, CResult_SignatureNoneZ_get_ok(owner_conv).compact_form, 64);
4172 static inline void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
4173 CHECK(!owner->result_ok);
4174 return *owner->contents.err;
4176 void __attribute__((export_name("TS_CResult_SignatureNoneZ_get_err"))) TS_CResult_SignatureNoneZ_get_err(uint64_t owner) {
4177 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(owner);
4178 CResult_SignatureNoneZ_get_err(owner_conv);
4181 static inline struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
4182 CHECK(owner->result_ok);
4183 return *owner->contents.result;
4185 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_ok"))) TS_CResult_PublicKeyNoneZ_get_ok(uint64_t owner) {
4186 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
4187 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4188 memcpy(ret_arr->elems, CResult_PublicKeyNoneZ_get_ok(owner_conv).compressed_form, 33);
4192 static inline void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
4193 CHECK(!owner->result_ok);
4194 return *owner->contents.err;
4196 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_err"))) TS_CResult_PublicKeyNoneZ_get_err(uint64_t owner) {
4197 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
4198 CResult_PublicKeyNoneZ_get_err(owner_conv);
4201 uint32_t __attribute__((export_name("TS_LDKCOption_ScalarZ_ty_from_ptr"))) TS_LDKCOption_ScalarZ_ty_from_ptr(uint64_t ptr) {
4202 LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
4204 case LDKCOption_ScalarZ_Some: return 0;
4205 case LDKCOption_ScalarZ_None: return 1;
4209 uint64_t __attribute__((export_name("TS_LDKCOption_ScalarZ_Some_get_some"))) TS_LDKCOption_ScalarZ_Some_get_some(uint64_t ptr) {
4210 LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
4211 assert(obj->tag == LDKCOption_ScalarZ_Some);
4212 LDKBigEndianScalar* some_ref = &obj->some;
4213 return tag_ptr(some_ref, false);
4215 static inline struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
4216 CHECK(owner->result_ok);
4217 return ThirtyTwoBytes_clone(&*owner->contents.result);
4219 int8_tArray __attribute__((export_name("TS_CResult_SharedSecretNoneZ_get_ok"))) TS_CResult_SharedSecretNoneZ_get_ok(uint64_t owner) {
4220 LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
4221 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4222 memcpy(ret_arr->elems, CResult_SharedSecretNoneZ_get_ok(owner_conv).data, 32);
4226 static inline void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
4227 CHECK(!owner->result_ok);
4228 return *owner->contents.err;
4230 void __attribute__((export_name("TS_CResult_SharedSecretNoneZ_get_err"))) TS_CResult_SharedSecretNoneZ_get_err(uint64_t owner) {
4231 LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
4232 CResult_SharedSecretNoneZ_get_err(owner_conv);
4235 static inline struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4236 CHECK(owner->result_ok);
4237 return *owner->contents.result;
4239 int8_tArray __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_ok"))) TS_CResult_RecoverableSignatureNoneZ_get_ok(uint64_t owner) {
4240 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
4241 int8_tArray ret_arr = init_int8_tArray(68, __LINE__);
4242 memcpy(ret_arr->elems, CResult_RecoverableSignatureNoneZ_get_ok(owner_conv).serialized_form, 68);
4246 static inline void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4247 CHECK(!owner->result_ok);
4248 return *owner->contents.err;
4250 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_err"))) TS_CResult_RecoverableSignatureNoneZ_get_err(uint64_t owner) {
4251 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
4252 CResult_RecoverableSignatureNoneZ_get_err(owner_conv);
4255 typedef struct LDKChannelSigner_JCalls {
4256 atomic_size_t refcnt;
4257 uint32_t instance_ptr;
4258 } LDKChannelSigner_JCalls;
4259 static void LDKChannelSigner_JCalls_free(void* this_arg) {
4260 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4261 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4265 LDKPublicKey get_per_commitment_point_LDKChannelSigner_jcall(const void* this_arg, uint64_t idx) {
4266 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4267 int64_t idx_conv = idx;
4268 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 2, idx_conv, 0, 0, 0, 0, 0);
4269 LDKPublicKey ret_ref;
4270 CHECK(ret->arr_len == 33);
4271 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
4274 LDKThirtyTwoBytes release_commitment_secret_LDKChannelSigner_jcall(const void* this_arg, uint64_t idx) {
4275 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4276 int64_t idx_conv = idx;
4277 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 3, idx_conv, 0, 0, 0, 0, 0);
4278 LDKThirtyTwoBytes ret_ref;
4279 CHECK(ret->arr_len == 32);
4280 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
4283 LDKCResult_NoneNoneZ validate_holder_commitment_LDKChannelSigner_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * holder_tx, LDKCVec_PaymentPreimageZ preimages) {
4284 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4285 LDKHolderCommitmentTransaction holder_tx_var = *holder_tx;
4286 uint64_t holder_tx_ref = 0;
4287 holder_tx_var = HolderCommitmentTransaction_clone(&holder_tx_var);
4288 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
4289 holder_tx_ref = tag_ptr(holder_tx_var.inner, holder_tx_var.is_owned);
4290 LDKCVec_PaymentPreimageZ preimages_var = preimages;
4291 ptrArray preimages_arr = NULL;
4292 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
4293 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
4294 for (size_t m = 0; m < preimages_var.datalen; m++) {
4295 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
4296 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
4297 preimages_arr_ptr[m] = preimages_conv_12_arr;
4300 FREE(preimages_var.data);
4301 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 4, holder_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
4302 void* ret_ptr = untag_ptr(ret);
4303 CHECK_ACCESS(ret_ptr);
4304 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
4305 FREE(untag_ptr(ret));
4308 LDKThirtyTwoBytes channel_keys_id_LDKChannelSigner_jcall(const void* this_arg) {
4309 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4310 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 5, 0, 0, 0, 0, 0, 0);
4311 LDKThirtyTwoBytes ret_ref;
4312 CHECK(ret->arr_len == 32);
4313 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
4316 void provide_channel_parameters_LDKChannelSigner_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
4317 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4318 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
4319 uint64_t channel_parameters_ref = 0;
4320 channel_parameters_var = ChannelTransactionParameters_clone(&channel_parameters_var);
4321 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
4322 channel_parameters_ref = tag_ptr(channel_parameters_var.inner, channel_parameters_var.is_owned);
4323 js_invoke_function_buuuuu(j_calls->instance_ptr, 6, channel_parameters_ref, 0, 0, 0, 0, 0);
4325 static void LDKChannelSigner_JCalls_cloned(LDKChannelSigner* new_obj) {
4326 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) new_obj->this_arg;
4327 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4329 static inline LDKChannelSigner LDKChannelSigner_init (JSValue o, uint64_t pubkeys) {
4330 LDKChannelSigner_JCalls *calls = MALLOC(sizeof(LDKChannelSigner_JCalls), "LDKChannelSigner_JCalls");
4331 atomic_init(&calls->refcnt, 1);
4332 calls->instance_ptr = o;
4334 LDKChannelPublicKeys pubkeys_conv;
4335 pubkeys_conv.inner = untag_ptr(pubkeys);
4336 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4337 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4339 LDKChannelSigner ret = {
4340 .this_arg = (void*) calls,
4341 .get_per_commitment_point = get_per_commitment_point_LDKChannelSigner_jcall,
4342 .release_commitment_secret = release_commitment_secret_LDKChannelSigner_jcall,
4343 .validate_holder_commitment = validate_holder_commitment_LDKChannelSigner_jcall,
4344 .channel_keys_id = channel_keys_id_LDKChannelSigner_jcall,
4345 .provide_channel_parameters = provide_channel_parameters_LDKChannelSigner_jcall,
4346 .free = LDKChannelSigner_JCalls_free,
4347 .pubkeys = pubkeys_conv,
4348 .set_pubkeys = NULL,
4352 uint64_t __attribute__((export_name("TS_LDKChannelSigner_new"))) TS_LDKChannelSigner_new(JSValue o, uint64_t pubkeys) {
4353 LDKChannelSigner *res_ptr = MALLOC(sizeof(LDKChannelSigner), "LDKChannelSigner");
4354 *res_ptr = LDKChannelSigner_init(o, pubkeys);
4355 return tag_ptr(res_ptr, true);
4357 int8_tArray __attribute__((export_name("TS_ChannelSigner_get_per_commitment_point"))) TS_ChannelSigner_get_per_commitment_point(uint64_t this_arg, int64_t idx) {
4358 void* this_arg_ptr = untag_ptr(this_arg);
4359 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4360 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4361 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4362 memcpy(ret_arr->elems, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form, 33);
4366 int8_tArray __attribute__((export_name("TS_ChannelSigner_release_commitment_secret"))) TS_ChannelSigner_release_commitment_secret(uint64_t this_arg, int64_t idx) {
4367 void* this_arg_ptr = untag_ptr(this_arg);
4368 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4369 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4370 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4371 memcpy(ret_arr->elems, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data, 32);
4375 uint64_t __attribute__((export_name("TS_ChannelSigner_validate_holder_commitment"))) TS_ChannelSigner_validate_holder_commitment(uint64_t this_arg, uint64_t holder_tx, ptrArray preimages) {
4376 void* this_arg_ptr = untag_ptr(this_arg);
4377 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4378 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4379 LDKHolderCommitmentTransaction holder_tx_conv;
4380 holder_tx_conv.inner = untag_ptr(holder_tx);
4381 holder_tx_conv.is_owned = ptr_is_owned(holder_tx);
4382 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
4383 holder_tx_conv.is_owned = false;
4384 LDKCVec_PaymentPreimageZ preimages_constr;
4385 preimages_constr.datalen = preimages->arr_len;
4386 if (preimages_constr.datalen > 0)
4387 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4389 preimages_constr.data = NULL;
4390 int8_tArray* preimages_vals = (void*) preimages->elems;
4391 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4392 int8_tArray preimages_conv_12 = preimages_vals[m];
4393 LDKThirtyTwoBytes preimages_conv_12_ref;
4394 CHECK(preimages_conv_12->arr_len == 32);
4395 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4396 preimages_constr.data[m] = preimages_conv_12_ref;
4399 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4400 *ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv, preimages_constr);
4401 return tag_ptr(ret_conv, true);
4404 int8_tArray __attribute__((export_name("TS_ChannelSigner_channel_keys_id"))) TS_ChannelSigner_channel_keys_id(uint64_t this_arg) {
4405 void* this_arg_ptr = untag_ptr(this_arg);
4406 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4407 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4408 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4409 memcpy(ret_arr->elems, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data, 32);
4413 void __attribute__((export_name("TS_ChannelSigner_provide_channel_parameters"))) TS_ChannelSigner_provide_channel_parameters(uint64_t this_arg, uint64_t channel_parameters) {
4414 void* this_arg_ptr = untag_ptr(this_arg);
4415 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4416 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4417 LDKChannelTransactionParameters channel_parameters_conv;
4418 channel_parameters_conv.inner = untag_ptr(channel_parameters);
4419 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
4420 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
4421 channel_parameters_conv.is_owned = false;
4422 (this_arg_conv->provide_channel_parameters)(this_arg_conv->this_arg, &channel_parameters_conv);
4425 LDKChannelPublicKeys LDKChannelSigner_set_get_pubkeys(LDKChannelSigner* this_arg) {
4426 if (this_arg->set_pubkeys != NULL)
4427 this_arg->set_pubkeys(this_arg);
4428 return this_arg->pubkeys;
4430 uint64_t __attribute__((export_name("TS_ChannelSigner_get_pubkeys"))) TS_ChannelSigner_get_pubkeys(uint64_t this_arg) {
4431 void* this_arg_ptr = untag_ptr(this_arg);
4432 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4433 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4434 LDKChannelPublicKeys ret_var = LDKChannelSigner_set_get_pubkeys(this_arg_conv);
4435 uint64_t ret_ref = 0;
4436 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4437 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4441 typedef struct LDKEcdsaChannelSigner_JCalls {
4442 atomic_size_t refcnt;
4443 uint32_t instance_ptr;
4444 LDKChannelSigner_JCalls* ChannelSigner;
4445 } LDKEcdsaChannelSigner_JCalls;
4446 static void LDKEcdsaChannelSigner_JCalls_free(void* this_arg) {
4447 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4448 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4452 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx, LDKCVec_PaymentPreimageZ preimages) {
4453 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4454 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
4455 uint64_t commitment_tx_ref = 0;
4456 commitment_tx_var = CommitmentTransaction_clone(&commitment_tx_var);
4457 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
4458 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
4459 LDKCVec_PaymentPreimageZ preimages_var = preimages;
4460 ptrArray preimages_arr = NULL;
4461 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
4462 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
4463 for (size_t m = 0; m < preimages_var.datalen; m++) {
4464 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
4465 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
4466 preimages_arr_ptr[m] = preimages_conv_12_arr;
4469 FREE(preimages_var.data);
4470 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 7, commitment_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
4471 void* ret_ptr = untag_ptr(ret);
4472 CHECK_ACCESS(ret_ptr);
4473 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
4474 FREE(untag_ptr(ret));
4477 LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKEcdsaChannelSigner_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
4478 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4479 int64_t idx_conv = idx;
4480 int8_tArray secret_arr = init_int8_tArray(32, __LINE__);
4481 memcpy(secret_arr->elems, *secret, 32);
4482 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 8, idx_conv, (uint32_t)secret_arr, 0, 0, 0, 0);
4483 void* ret_ptr = untag_ptr(ret);
4484 CHECK_ACCESS(ret_ptr);
4485 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
4486 FREE(untag_ptr(ret));
4489 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
4490 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4491 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
4492 uint64_t commitment_tx_ref = 0;
4493 commitment_tx_var = HolderCommitmentTransaction_clone(&commitment_tx_var);
4494 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
4495 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
4496 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 9, commitment_tx_ref, 0, 0, 0, 0, 0);
4497 void* ret_ptr = untag_ptr(ret);
4498 CHECK_ACCESS(ret_ptr);
4499 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
4500 FREE(untag_ptr(ret));
4503 LDKCResult_SignatureNoneZ sign_justice_revoked_output_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32]) {
4504 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4505 LDKTransaction justice_tx_var = justice_tx;
4506 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
4507 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
4508 Transaction_free(justice_tx_var);
4509 uint32_t input_conv = input;
4510 int64_t amount_conv = amount;
4511 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
4512 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
4513 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 10, (uint32_t)justice_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_key_arr, 0, 0);
4514 void* ret_ptr = untag_ptr(ret);
4515 CHECK_ACCESS(ret_ptr);
4516 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4517 FREE(untag_ptr(ret));
4520 LDKCResult_SignatureNoneZ sign_justice_revoked_htlc_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
4521 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4522 LDKTransaction justice_tx_var = justice_tx;
4523 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
4524 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
4525 Transaction_free(justice_tx_var);
4526 uint32_t input_conv = input;
4527 int64_t amount_conv = amount;
4528 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
4529 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
4530 LDKHTLCOutputInCommitment htlc_var = *htlc;
4531 uint64_t htlc_ref = 0;
4532 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4533 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4534 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
4535 uint64_t ret = js_invoke_function_uububu(j_calls->instance_ptr, 11, (uint32_t)justice_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_key_arr, htlc_ref, 0);
4536 void* ret_ptr = untag_ptr(ret);
4537 CHECK_ACCESS(ret_ptr);
4538 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4539 FREE(untag_ptr(ret));
4542 LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
4543 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4544 LDKTransaction htlc_tx_var = htlc_tx;
4545 int8_tArray htlc_tx_arr = init_int8_tArray(htlc_tx_var.datalen, __LINE__);
4546 memcpy(htlc_tx_arr->elems, htlc_tx_var.data, htlc_tx_var.datalen);
4547 Transaction_free(htlc_tx_var);
4548 uint32_t input_conv = input;
4549 int64_t amount_conv = amount;
4550 int8_tArray per_commitment_point_arr = init_int8_tArray(33, __LINE__);
4551 memcpy(per_commitment_point_arr->elems, per_commitment_point.compressed_form, 33);
4552 LDKHTLCOutputInCommitment htlc_var = *htlc;
4553 uint64_t htlc_ref = 0;
4554 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4555 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4556 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
4557 uint64_t ret = js_invoke_function_uububu(j_calls->instance_ptr, 12, (uint32_t)htlc_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_point_arr, htlc_ref, 0);
4558 void* ret_ptr = untag_ptr(ret);
4559 CHECK_ACCESS(ret_ptr);
4560 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4561 FREE(untag_ptr(ret));
4564 LDKCResult_SignatureNoneZ sign_closing_transaction_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
4565 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4566 LDKClosingTransaction closing_tx_var = *closing_tx;
4567 uint64_t closing_tx_ref = 0;
4568 closing_tx_var = ClosingTransaction_clone(&closing_tx_var);
4569 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
4570 closing_tx_ref = tag_ptr(closing_tx_var.inner, closing_tx_var.is_owned);
4571 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 13, closing_tx_ref, 0, 0, 0, 0, 0);
4572 void* ret_ptr = untag_ptr(ret);
4573 CHECK_ACCESS(ret_ptr);
4574 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4575 FREE(untag_ptr(ret));
4578 LDKCResult_SignatureNoneZ sign_holder_anchor_input_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction anchor_tx, uintptr_t input) {
4579 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4580 LDKTransaction anchor_tx_var = anchor_tx;
4581 int8_tArray anchor_tx_arr = init_int8_tArray(anchor_tx_var.datalen, __LINE__);
4582 memcpy(anchor_tx_arr->elems, anchor_tx_var.data, anchor_tx_var.datalen);
4583 Transaction_free(anchor_tx_var);
4584 uint32_t input_conv = input;
4585 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 14, (uint32_t)anchor_tx_arr, input_conv, 0, 0, 0, 0);
4586 void* ret_ptr = untag_ptr(ret);
4587 CHECK_ACCESS(ret_ptr);
4588 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4589 FREE(untag_ptr(ret));
4592 LDKCResult_SignatureNoneZ sign_channel_announcement_with_funding_key_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
4593 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4594 LDKUnsignedChannelAnnouncement msg_var = *msg;
4595 uint64_t msg_ref = 0;
4596 msg_var = UnsignedChannelAnnouncement_clone(&msg_var);
4597 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4598 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
4599 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 15, msg_ref, 0, 0, 0, 0, 0);
4600 void* ret_ptr = untag_ptr(ret);
4601 CHECK_ACCESS(ret_ptr);
4602 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4603 FREE(untag_ptr(ret));
4606 static void LDKEcdsaChannelSigner_JCalls_cloned(LDKEcdsaChannelSigner* new_obj) {
4607 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) new_obj->this_arg;
4608 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4609 atomic_fetch_add_explicit(&j_calls->ChannelSigner->refcnt, 1, memory_order_release);
4611 static inline LDKEcdsaChannelSigner LDKEcdsaChannelSigner_init (JSValue o, JSValue ChannelSigner, uint64_t pubkeys) {
4612 LDKEcdsaChannelSigner_JCalls *calls = MALLOC(sizeof(LDKEcdsaChannelSigner_JCalls), "LDKEcdsaChannelSigner_JCalls");
4613 atomic_init(&calls->refcnt, 1);
4614 calls->instance_ptr = o;
4616 LDKChannelPublicKeys pubkeys_conv;
4617 pubkeys_conv.inner = untag_ptr(pubkeys);
4618 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4619 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4621 LDKEcdsaChannelSigner ret = {
4622 .this_arg = (void*) calls,
4623 .sign_counterparty_commitment = sign_counterparty_commitment_LDKEcdsaChannelSigner_jcall,
4624 .validate_counterparty_revocation = validate_counterparty_revocation_LDKEcdsaChannelSigner_jcall,
4625 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKEcdsaChannelSigner_jcall,
4626 .sign_justice_revoked_output = sign_justice_revoked_output_LDKEcdsaChannelSigner_jcall,
4627 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKEcdsaChannelSigner_jcall,
4628 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKEcdsaChannelSigner_jcall,
4629 .sign_closing_transaction = sign_closing_transaction_LDKEcdsaChannelSigner_jcall,
4630 .sign_holder_anchor_input = sign_holder_anchor_input_LDKEcdsaChannelSigner_jcall,
4631 .sign_channel_announcement_with_funding_key = sign_channel_announcement_with_funding_key_LDKEcdsaChannelSigner_jcall,
4632 .free = LDKEcdsaChannelSigner_JCalls_free,
4633 .ChannelSigner = LDKChannelSigner_init(ChannelSigner, pubkeys),
4635 calls->ChannelSigner = ret.ChannelSigner.this_arg;
4638 uint64_t __attribute__((export_name("TS_LDKEcdsaChannelSigner_new"))) TS_LDKEcdsaChannelSigner_new(JSValue o, JSValue ChannelSigner, uint64_t pubkeys) {
4639 LDKEcdsaChannelSigner *res_ptr = MALLOC(sizeof(LDKEcdsaChannelSigner), "LDKEcdsaChannelSigner");
4640 *res_ptr = LDKEcdsaChannelSigner_init(o, ChannelSigner, pubkeys);
4641 return tag_ptr(res_ptr, true);
4643 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_counterparty_commitment"))) TS_EcdsaChannelSigner_sign_counterparty_commitment(uint64_t this_arg, uint64_t commitment_tx, ptrArray preimages) {
4644 void* this_arg_ptr = untag_ptr(this_arg);
4645 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4646 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4647 LDKCommitmentTransaction commitment_tx_conv;
4648 commitment_tx_conv.inner = untag_ptr(commitment_tx);
4649 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
4650 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4651 commitment_tx_conv.is_owned = false;
4652 LDKCVec_PaymentPreimageZ preimages_constr;
4653 preimages_constr.datalen = preimages->arr_len;
4654 if (preimages_constr.datalen > 0)
4655 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4657 preimages_constr.data = NULL;
4658 int8_tArray* preimages_vals = (void*) preimages->elems;
4659 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4660 int8_tArray preimages_conv_12 = preimages_vals[m];
4661 LDKThirtyTwoBytes preimages_conv_12_ref;
4662 CHECK(preimages_conv_12->arr_len == 32);
4663 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4664 preimages_constr.data[m] = preimages_conv_12_ref;
4667 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4668 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv, preimages_constr);
4669 return tag_ptr(ret_conv, true);
4672 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_validate_counterparty_revocation"))) TS_EcdsaChannelSigner_validate_counterparty_revocation(uint64_t this_arg, int64_t idx, int8_tArray secret) {
4673 void* this_arg_ptr = untag_ptr(this_arg);
4674 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4675 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4676 uint8_t secret_arr[32];
4677 CHECK(secret->arr_len == 32);
4678 memcpy(secret_arr, secret->elems, 32); FREE(secret);
4679 uint8_t (*secret_ref)[32] = &secret_arr;
4680 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4681 *ret_conv = (this_arg_conv->validate_counterparty_revocation)(this_arg_conv->this_arg, idx, secret_ref);
4682 return tag_ptr(ret_conv, true);
4685 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_holder_commitment_and_htlcs"))) TS_EcdsaChannelSigner_sign_holder_commitment_and_htlcs(uint64_t this_arg, uint64_t commitment_tx) {
4686 void* this_arg_ptr = untag_ptr(this_arg);
4687 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4688 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4689 LDKHolderCommitmentTransaction commitment_tx_conv;
4690 commitment_tx_conv.inner = untag_ptr(commitment_tx);
4691 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
4692 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4693 commitment_tx_conv.is_owned = false;
4694 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4695 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
4696 return tag_ptr(ret_conv, true);
4699 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_justice_revoked_output"))) TS_EcdsaChannelSigner_sign_justice_revoked_output(uint64_t this_arg, int8_tArray justice_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_key) {
4700 void* this_arg_ptr = untag_ptr(this_arg);
4701 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4702 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4703 LDKTransaction justice_tx_ref;
4704 justice_tx_ref.datalen = justice_tx->arr_len;
4705 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4706 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4707 justice_tx_ref.data_is_owned = true;
4708 uint8_t per_commitment_key_arr[32];
4709 CHECK(per_commitment_key->arr_len == 32);
4710 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4711 uint8_t (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4712 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4713 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
4714 return tag_ptr(ret_conv, true);
4717 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_justice_revoked_htlc"))) TS_EcdsaChannelSigner_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) {
4718 void* this_arg_ptr = untag_ptr(this_arg);
4719 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4720 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4721 LDKTransaction justice_tx_ref;
4722 justice_tx_ref.datalen = justice_tx->arr_len;
4723 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4724 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4725 justice_tx_ref.data_is_owned = true;
4726 uint8_t per_commitment_key_arr[32];
4727 CHECK(per_commitment_key->arr_len == 32);
4728 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4729 uint8_t (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4730 LDKHTLCOutputInCommitment htlc_conv;
4731 htlc_conv.inner = untag_ptr(htlc);
4732 htlc_conv.is_owned = ptr_is_owned(htlc);
4733 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4734 htlc_conv.is_owned = false;
4735 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4736 *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);
4737 return tag_ptr(ret_conv, true);
4740 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction"))) TS_EcdsaChannelSigner_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) {
4741 void* this_arg_ptr = untag_ptr(this_arg);
4742 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4743 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4744 LDKTransaction htlc_tx_ref;
4745 htlc_tx_ref.datalen = htlc_tx->arr_len;
4746 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
4747 memcpy(htlc_tx_ref.data, htlc_tx->elems, htlc_tx_ref.datalen); FREE(htlc_tx);
4748 htlc_tx_ref.data_is_owned = true;
4749 LDKPublicKey per_commitment_point_ref;
4750 CHECK(per_commitment_point->arr_len == 33);
4751 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
4752 LDKHTLCOutputInCommitment htlc_conv;
4753 htlc_conv.inner = untag_ptr(htlc);
4754 htlc_conv.is_owned = ptr_is_owned(htlc);
4755 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4756 htlc_conv.is_owned = false;
4757 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4758 *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);
4759 return tag_ptr(ret_conv, true);
4762 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_closing_transaction"))) TS_EcdsaChannelSigner_sign_closing_transaction(uint64_t this_arg, uint64_t closing_tx) {
4763 void* this_arg_ptr = untag_ptr(this_arg);
4764 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4765 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4766 LDKClosingTransaction closing_tx_conv;
4767 closing_tx_conv.inner = untag_ptr(closing_tx);
4768 closing_tx_conv.is_owned = ptr_is_owned(closing_tx);
4769 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
4770 closing_tx_conv.is_owned = false;
4771 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4772 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
4773 return tag_ptr(ret_conv, true);
4776 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_holder_anchor_input"))) TS_EcdsaChannelSigner_sign_holder_anchor_input(uint64_t this_arg, int8_tArray anchor_tx, uint32_t input) {
4777 void* this_arg_ptr = untag_ptr(this_arg);
4778 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4779 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4780 LDKTransaction anchor_tx_ref;
4781 anchor_tx_ref.datalen = anchor_tx->arr_len;
4782 anchor_tx_ref.data = MALLOC(anchor_tx_ref.datalen, "LDKTransaction Bytes");
4783 memcpy(anchor_tx_ref.data, anchor_tx->elems, anchor_tx_ref.datalen); FREE(anchor_tx);
4784 anchor_tx_ref.data_is_owned = true;
4785 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4786 *ret_conv = (this_arg_conv->sign_holder_anchor_input)(this_arg_conv->this_arg, anchor_tx_ref, input);
4787 return tag_ptr(ret_conv, true);
4790 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key"))) TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(uint64_t this_arg, uint64_t msg) {
4791 void* this_arg_ptr = untag_ptr(this_arg);
4792 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4793 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4794 LDKUnsignedChannelAnnouncement msg_conv;
4795 msg_conv.inner = untag_ptr(msg);
4796 msg_conv.is_owned = ptr_is_owned(msg);
4797 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
4798 msg_conv.is_owned = false;
4799 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4800 *ret_conv = (this_arg_conv->sign_channel_announcement_with_funding_key)(this_arg_conv->this_arg, &msg_conv);
4801 return tag_ptr(ret_conv, true);
4804 typedef struct LDKWriteableEcdsaChannelSigner_JCalls {
4805 atomic_size_t refcnt;
4806 uint32_t instance_ptr;
4807 LDKEcdsaChannelSigner_JCalls* EcdsaChannelSigner;
4808 LDKChannelSigner_JCalls* ChannelSigner;
4809 } LDKWriteableEcdsaChannelSigner_JCalls;
4810 static void LDKWriteableEcdsaChannelSigner_JCalls_free(void* this_arg) {
4811 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) this_arg;
4812 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4816 LDKCVec_u8Z write_LDKWriteableEcdsaChannelSigner_jcall(const void* this_arg) {
4817 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) this_arg;
4818 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 16, 0, 0, 0, 0, 0, 0);
4819 LDKCVec_u8Z ret_ref;
4820 ret_ref.datalen = ret->arr_len;
4821 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
4822 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
4825 static void LDKWriteableEcdsaChannelSigner_JCalls_cloned(LDKWriteableEcdsaChannelSigner* new_obj) {
4826 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) new_obj->this_arg;
4827 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4828 atomic_fetch_add_explicit(&j_calls->EcdsaChannelSigner->refcnt, 1, memory_order_release);
4829 atomic_fetch_add_explicit(&j_calls->EcdsaChannelSigner->ChannelSigner->refcnt, 1, memory_order_release);
4831 static inline LDKWriteableEcdsaChannelSigner LDKWriteableEcdsaChannelSigner_init (JSValue o, JSValue EcdsaChannelSigner, JSValue ChannelSigner, uint64_t pubkeys) {
4832 LDKWriteableEcdsaChannelSigner_JCalls *calls = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner_JCalls), "LDKWriteableEcdsaChannelSigner_JCalls");
4833 atomic_init(&calls->refcnt, 1);
4834 calls->instance_ptr = o;
4836 LDKChannelPublicKeys pubkeys_conv;
4837 pubkeys_conv.inner = untag_ptr(pubkeys);
4838 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4839 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4841 LDKWriteableEcdsaChannelSigner ret = {
4842 .this_arg = (void*) calls,
4843 .write = write_LDKWriteableEcdsaChannelSigner_jcall,
4844 .cloned = LDKWriteableEcdsaChannelSigner_JCalls_cloned,
4845 .free = LDKWriteableEcdsaChannelSigner_JCalls_free,
4846 .EcdsaChannelSigner = LDKEcdsaChannelSigner_init(EcdsaChannelSigner, ChannelSigner, pubkeys),
4848 calls->EcdsaChannelSigner = ret.EcdsaChannelSigner.this_arg;
4849 calls->ChannelSigner = ret.EcdsaChannelSigner.ChannelSigner.this_arg;
4852 uint64_t __attribute__((export_name("TS_LDKWriteableEcdsaChannelSigner_new"))) TS_LDKWriteableEcdsaChannelSigner_new(JSValue o, JSValue EcdsaChannelSigner, JSValue ChannelSigner, uint64_t pubkeys) {
4853 LDKWriteableEcdsaChannelSigner *res_ptr = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
4854 *res_ptr = LDKWriteableEcdsaChannelSigner_init(o, EcdsaChannelSigner, ChannelSigner, pubkeys);
4855 return tag_ptr(res_ptr, true);
4857 int8_tArray __attribute__((export_name("TS_WriteableEcdsaChannelSigner_write"))) TS_WriteableEcdsaChannelSigner_write(uint64_t this_arg) {
4858 void* this_arg_ptr = untag_ptr(this_arg);
4859 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4860 LDKWriteableEcdsaChannelSigner* this_arg_conv = (LDKWriteableEcdsaChannelSigner*)this_arg_ptr;
4861 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
4862 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4863 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4864 CVec_u8Z_free(ret_var);
4868 static inline struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner){
4869 CHECK(owner->result_ok);
4870 return WriteableEcdsaChannelSigner_clone(&*owner->contents.result);
4872 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(uint64_t owner) {
4873 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* owner_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(owner);
4874 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
4875 *ret_ret = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner_conv);
4876 return tag_ptr(ret_ret, true);
4879 static inline struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner){
4880 CHECK(!owner->result_ok);
4881 return DecodeError_clone(&*owner->contents.err);
4883 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(uint64_t owner) {
4884 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* owner_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(owner);
4885 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4886 *ret_copy = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner_conv);
4887 uint64_t ret_ref = tag_ptr(ret_copy, true);
4891 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
4892 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
4893 for (size_t i = 0; i < ret.datalen; i++) {
4894 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
4898 static inline struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4899 CHECK(owner->result_ok);
4900 return CVec_CVec_u8ZZ_clone(&*owner->contents.result);
4902 ptrArray __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(uint64_t owner) {
4903 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
4904 LDKCVec_CVec_u8ZZ ret_var = CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner_conv);
4905 ptrArray ret_arr = NULL;
4906 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
4907 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
4908 for (size_t m = 0; m < ret_var.datalen; m++) {
4909 LDKCVec_u8Z ret_conv_12_var = ret_var.data[m];
4910 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
4911 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
4912 CVec_u8Z_free(ret_conv_12_var);
4913 ret_arr_ptr[m] = ret_conv_12_arr;
4920 static inline void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4921 CHECK(!owner->result_ok);
4922 return *owner->contents.err;
4924 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(uint64_t owner) {
4925 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
4926 CResult_CVec_CVec_u8ZZNoneZ_get_err(owner_conv);
4929 static inline struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4930 LDKInMemorySigner ret = *owner->contents.result;
4931 ret.is_owned = false;
4934 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_get_ok(uint64_t owner) {
4935 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
4936 LDKInMemorySigner ret_var = CResult_InMemorySignerDecodeErrorZ_get_ok(owner_conv);
4937 uint64_t ret_ref = 0;
4938 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4939 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4943 static inline struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4944 CHECK(!owner->result_ok);
4945 return DecodeError_clone(&*owner->contents.err);
4947 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_err"))) TS_CResult_InMemorySignerDecodeErrorZ_get_err(uint64_t owner) {
4948 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
4949 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4950 *ret_copy = CResult_InMemorySignerDecodeErrorZ_get_err(owner_conv);
4951 uint64_t ret_ref = tag_ptr(ret_copy, true);
4955 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
4956 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
4957 for (size_t i = 0; i < ret.datalen; i++) {
4958 ret.data[i] = TxOut_clone(&orig->data[i]);
4962 static inline struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4963 CHECK(owner->result_ok);
4964 return *owner->contents.result;
4966 int8_tArray __attribute__((export_name("TS_CResult_TransactionNoneZ_get_ok"))) TS_CResult_TransactionNoneZ_get_ok(uint64_t owner) {
4967 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
4968 LDKTransaction ret_var = CResult_TransactionNoneZ_get_ok(owner_conv);
4969 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4970 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4974 static inline void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4975 CHECK(!owner->result_ok);
4976 return *owner->contents.err;
4978 void __attribute__((export_name("TS_CResult_TransactionNoneZ_get_err"))) TS_CResult_TransactionNoneZ_get_err(uint64_t owner) {
4979 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
4980 CResult_TransactionNoneZ_get_err(owner_conv);
4983 uint32_t __attribute__((export_name("TS_LDKCOption_u16Z_ty_from_ptr"))) TS_LDKCOption_u16Z_ty_from_ptr(uint64_t ptr) {
4984 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
4986 case LDKCOption_u16Z_Some: return 0;
4987 case LDKCOption_u16Z_None: return 1;
4991 int16_t __attribute__((export_name("TS_LDKCOption_u16Z_Some_get_some"))) TS_LDKCOption_u16Z_Some_get_some(uint64_t ptr) {
4992 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
4993 assert(obj->tag == LDKCOption_u16Z_Some);
4994 int16_t some_conv = obj->some;
4997 static inline struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
4998 CHECK(owner->result_ok);
4999 return ThirtyTwoBytes_clone(&*owner->contents.result);
5001 int8_tArray __attribute__((export_name("TS_CResult__u832APIErrorZ_get_ok"))) TS_CResult__u832APIErrorZ_get_ok(uint64_t owner) {
5002 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(owner);
5003 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5004 memcpy(ret_arr->elems, CResult__u832APIErrorZ_get_ok(owner_conv).data, 32);
5008 static inline struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
5009 CHECK(!owner->result_ok);
5010 return APIError_clone(&*owner->contents.err);
5012 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_get_err"))) TS_CResult__u832APIErrorZ_get_err(uint64_t owner) {
5013 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(owner);
5014 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5015 *ret_copy = CResult__u832APIErrorZ_get_err(owner_conv);
5016 uint64_t ret_ref = tag_ptr(ret_copy, true);
5020 uint32_t __attribute__((export_name("TS_LDKRecentPaymentDetails_ty_from_ptr"))) TS_LDKRecentPaymentDetails_ty_from_ptr(uint64_t ptr) {
5021 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5023 case LDKRecentPaymentDetails_Pending: return 0;
5024 case LDKRecentPaymentDetails_Fulfilled: return 1;
5025 case LDKRecentPaymentDetails_Abandoned: return 2;
5029 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_payment_hash"))) TS_LDKRecentPaymentDetails_Pending_get_payment_hash(uint64_t ptr) {
5030 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5031 assert(obj->tag == LDKRecentPaymentDetails_Pending);
5032 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
5033 memcpy(payment_hash_arr->elems, obj->pending.payment_hash.data, 32);
5034 return payment_hash_arr;
5036 int64_t __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_total_msat"))) TS_LDKRecentPaymentDetails_Pending_get_total_msat(uint64_t ptr) {
5037 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5038 assert(obj->tag == LDKRecentPaymentDetails_Pending);
5039 int64_t total_msat_conv = obj->pending.total_msat;
5040 return total_msat_conv;
5042 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash"))) TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(uint64_t ptr) {
5043 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5044 assert(obj->tag == LDKRecentPaymentDetails_Fulfilled);
5045 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
5046 memcpy(payment_hash_arr->elems, obj->fulfilled.payment_hash.data, 32);
5047 return payment_hash_arr;
5049 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash"))) TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(uint64_t ptr) {
5050 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5051 assert(obj->tag == LDKRecentPaymentDetails_Abandoned);
5052 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
5053 memcpy(payment_hash_arr->elems, obj->abandoned.payment_hash.data, 32);
5054 return payment_hash_arr;
5056 static inline LDKCVec_RecentPaymentDetailsZ CVec_RecentPaymentDetailsZ_clone(const LDKCVec_RecentPaymentDetailsZ *orig) {
5057 LDKCVec_RecentPaymentDetailsZ ret = { .data = MALLOC(sizeof(LDKRecentPaymentDetails) * orig->datalen, "LDKCVec_RecentPaymentDetailsZ clone bytes"), .datalen = orig->datalen };
5058 for (size_t i = 0; i < ret.datalen; i++) {
5059 ret.data[i] = RecentPaymentDetails_clone(&orig->data[i]);
5063 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_ty_from_ptr"))) TS_LDKPaymentSendFailure_ty_from_ptr(uint64_t ptr) {
5064 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5066 case LDKPaymentSendFailure_ParameterError: return 0;
5067 case LDKPaymentSendFailure_PathParameterError: return 1;
5068 case LDKPaymentSendFailure_AllFailedResendSafe: return 2;
5069 case LDKPaymentSendFailure_DuplicatePayment: return 3;
5070 case LDKPaymentSendFailure_PartialFailure: return 4;
5074 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_ParameterError_get_parameter_error"))) TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(uint64_t ptr) {
5075 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5076 assert(obj->tag == LDKPaymentSendFailure_ParameterError);
5077 uint64_t parameter_error_ref = tag_ptr(&obj->parameter_error, false);
5078 return parameter_error_ref;
5080 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error"))) TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(uint64_t ptr) {
5081 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5082 assert(obj->tag == LDKPaymentSendFailure_PathParameterError);
5083 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
5084 uint64_tArray path_parameter_error_arr = NULL;
5085 path_parameter_error_arr = init_uint64_tArray(path_parameter_error_var.datalen, __LINE__);
5086 uint64_t *path_parameter_error_arr_ptr = (uint64_t*)(((uint8_t*)path_parameter_error_arr) + 8);
5087 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
5088 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
5089 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
5090 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
5091 path_parameter_error_arr_ptr[w] = tag_ptr(path_parameter_error_conv_22_conv, true);
5094 return path_parameter_error_arr;
5096 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe"))) TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(uint64_t ptr) {
5097 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5098 assert(obj->tag == LDKPaymentSendFailure_AllFailedResendSafe);
5099 LDKCVec_APIErrorZ all_failed_resend_safe_var = obj->all_failed_resend_safe;
5100 uint64_tArray all_failed_resend_safe_arr = NULL;
5101 all_failed_resend_safe_arr = init_uint64_tArray(all_failed_resend_safe_var.datalen, __LINE__);
5102 uint64_t *all_failed_resend_safe_arr_ptr = (uint64_t*)(((uint8_t*)all_failed_resend_safe_arr) + 8);
5103 for (size_t k = 0; k < all_failed_resend_safe_var.datalen; k++) {
5104 uint64_t all_failed_resend_safe_conv_10_ref = tag_ptr(&all_failed_resend_safe_var.data[k], false);
5105 all_failed_resend_safe_arr_ptr[k] = all_failed_resend_safe_conv_10_ref;
5108 return all_failed_resend_safe_arr;
5110 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_results"))) TS_LDKPaymentSendFailure_PartialFailure_get_results(uint64_t ptr) {
5111 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5112 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
5113 LDKCVec_CResult_NoneAPIErrorZZ results_var = obj->partial_failure.results;
5114 uint64_tArray results_arr = NULL;
5115 results_arr = init_uint64_tArray(results_var.datalen, __LINE__);
5116 uint64_t *results_arr_ptr = (uint64_t*)(((uint8_t*)results_arr) + 8);
5117 for (size_t w = 0; w < results_var.datalen; w++) {
5118 LDKCResult_NoneAPIErrorZ* results_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
5119 *results_conv_22_conv = results_var.data[w];
5120 *results_conv_22_conv = CResult_NoneAPIErrorZ_clone(results_conv_22_conv);
5121 results_arr_ptr[w] = tag_ptr(results_conv_22_conv, true);
5126 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry"))) TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(uint64_t ptr) {
5127 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5128 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
5129 LDKRouteParameters failed_paths_retry_var = obj->partial_failure.failed_paths_retry;
5130 uint64_t failed_paths_retry_ref = 0;
5131 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
5132 failed_paths_retry_ref = tag_ptr(failed_paths_retry_var.inner, false);
5133 return failed_paths_retry_ref;
5135 int8_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_payment_id"))) TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(uint64_t ptr) {
5136 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5137 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
5138 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
5139 memcpy(payment_id_arr->elems, obj->partial_failure.payment_id.data, 32);
5140 return payment_id_arr;
5142 static inline void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
5143 CHECK(owner->result_ok);
5144 return *owner->contents.result;
5146 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_ok"))) TS_CResult_NonePaymentSendFailureZ_get_ok(uint64_t owner) {
5147 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
5148 CResult_NonePaymentSendFailureZ_get_ok(owner_conv);
5151 static inline struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
5152 CHECK(!owner->result_ok);
5153 return PaymentSendFailure_clone(&*owner->contents.err);
5155 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_err"))) TS_CResult_NonePaymentSendFailureZ_get_err(uint64_t owner) {
5156 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
5157 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
5158 *ret_copy = CResult_NonePaymentSendFailureZ_get_err(owner_conv);
5159 uint64_t ret_ref = tag_ptr(ret_copy, true);
5163 static inline void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner){
5164 CHECK(owner->result_ok);
5165 return *owner->contents.result;
5167 void __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_get_ok"))) TS_CResult_NoneRetryableSendFailureZ_get_ok(uint64_t owner) {
5168 LDKCResult_NoneRetryableSendFailureZ* owner_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(owner);
5169 CResult_NoneRetryableSendFailureZ_get_ok(owner_conv);
5172 static inline enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner){
5173 CHECK(!owner->result_ok);
5174 return RetryableSendFailure_clone(&*owner->contents.err);
5176 uint32_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_get_err"))) TS_CResult_NoneRetryableSendFailureZ_get_err(uint64_t owner) {
5177 LDKCResult_NoneRetryableSendFailureZ* owner_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(owner);
5178 uint32_t ret_conv = LDKRetryableSendFailure_to_js(CResult_NoneRetryableSendFailureZ_get_err(owner_conv));
5182 static inline struct LDKThirtyTwoBytes CResult_PaymentHashPaymentSendFailureZ_get_ok(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner){
5183 CHECK(owner->result_ok);
5184 return ThirtyTwoBytes_clone(&*owner->contents.result);
5186 int8_tArray __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_get_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_get_ok(uint64_t owner) {
5187 LDKCResult_PaymentHashPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(owner);
5188 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5189 memcpy(ret_arr->elems, CResult_PaymentHashPaymentSendFailureZ_get_ok(owner_conv).data, 32);
5193 static inline struct LDKPaymentSendFailure CResult_PaymentHashPaymentSendFailureZ_get_err(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner){
5194 CHECK(!owner->result_ok);
5195 return PaymentSendFailure_clone(&*owner->contents.err);
5197 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_get_err"))) TS_CResult_PaymentHashPaymentSendFailureZ_get_err(uint64_t owner) {
5198 LDKCResult_PaymentHashPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(owner);
5199 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
5200 *ret_copy = CResult_PaymentHashPaymentSendFailureZ_get_err(owner_conv);
5201 uint64_t ret_ref = tag_ptr(ret_copy, true);
5205 static inline struct LDKThirtyTwoBytes CResult_PaymentHashRetryableSendFailureZ_get_ok(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner){
5206 CHECK(owner->result_ok);
5207 return ThirtyTwoBytes_clone(&*owner->contents.result);
5209 int8_tArray __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_get_ok"))) TS_CResult_PaymentHashRetryableSendFailureZ_get_ok(uint64_t owner) {
5210 LDKCResult_PaymentHashRetryableSendFailureZ* owner_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(owner);
5211 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5212 memcpy(ret_arr->elems, CResult_PaymentHashRetryableSendFailureZ_get_ok(owner_conv).data, 32);
5216 static inline enum LDKRetryableSendFailure CResult_PaymentHashRetryableSendFailureZ_get_err(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner){
5217 CHECK(!owner->result_ok);
5218 return RetryableSendFailure_clone(&*owner->contents.err);
5220 uint32_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_get_err"))) TS_CResult_PaymentHashRetryableSendFailureZ_get_err(uint64_t owner) {
5221 LDKCResult_PaymentHashRetryableSendFailureZ* owner_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(owner);
5222 uint32_t ret_conv = LDKRetryableSendFailure_to_js(CResult_PaymentHashRetryableSendFailureZ_get_err(owner_conv));
5226 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
5227 return ThirtyTwoBytes_clone(&owner->a);
5229 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_a"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_a(uint64_t owner) {
5230 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(owner);
5231 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5232 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_a(owner_conv).data, 32);
5236 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
5237 return ThirtyTwoBytes_clone(&owner->b);
5239 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_b"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_b(uint64_t owner) {
5240 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(owner);
5241 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5242 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_b(owner_conv).data, 32);
5246 static inline struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
5247 CHECK(owner->result_ok);
5248 return C2Tuple_PaymentHashPaymentIdZ_clone(&*owner->contents.result);
5250 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint64_t owner) {
5251 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(owner);
5252 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
5253 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner_conv);
5254 return tag_ptr(ret_conv, true);
5257 static inline struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
5258 CHECK(!owner->result_ok);
5259 return PaymentSendFailure_clone(&*owner->contents.err);
5261 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(uint64_t owner) {
5262 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(owner);
5263 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
5264 *ret_copy = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner_conv);
5265 uint64_t ret_ref = tag_ptr(ret_copy, true);
5269 static inline LDKCVec_ThirtyTwoBytesZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_ThirtyTwoBytesZ *orig) {
5270 LDKCVec_ThirtyTwoBytesZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ThirtyTwoBytesZ clone bytes"), .datalen = orig->datalen };
5271 for (size_t i = 0; i < ret.datalen; i++) {
5272 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
5276 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
5277 return ThirtyTwoBytes_clone(&owner->a);
5279 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_a"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(uint64_t owner) {
5280 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(owner);
5281 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5282 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_a(owner_conv).data, 32);
5286 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
5287 return ThirtyTwoBytes_clone(&owner->b);
5289 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_b"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(uint64_t owner) {
5290 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(owner);
5291 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5292 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_b(owner_conv).data, 32);
5296 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
5297 CHECK(owner->result_ok);
5298 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
5300 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(uint64_t owner) {
5301 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(owner);
5302 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
5303 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner_conv);
5304 return tag_ptr(ret_conv, true);
5307 static inline void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
5308 CHECK(!owner->result_ok);
5309 return *owner->contents.err;
5311 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(uint64_t owner) {
5312 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(owner);
5313 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner_conv);
5316 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
5317 CHECK(owner->result_ok);
5318 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
5320 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(uint64_t owner) {
5321 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(owner);
5322 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
5323 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner_conv);
5324 return tag_ptr(ret_conv, true);
5327 static inline struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
5328 CHECK(!owner->result_ok);
5329 return APIError_clone(&*owner->contents.err);
5331 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(uint64_t owner) {
5332 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(owner);
5333 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5334 *ret_copy = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner_conv);
5335 uint64_t ret_ref = tag_ptr(ret_copy, true);
5339 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
5340 CHECK(owner->result_ok);
5341 return ThirtyTwoBytes_clone(&*owner->contents.result);
5343 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_ok"))) TS_CResult_PaymentSecretNoneZ_get_ok(uint64_t owner) {
5344 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(owner);
5345 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5346 memcpy(ret_arr->elems, CResult_PaymentSecretNoneZ_get_ok(owner_conv).data, 32);
5350 static inline void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
5351 CHECK(!owner->result_ok);
5352 return *owner->contents.err;
5354 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_err"))) TS_CResult_PaymentSecretNoneZ_get_err(uint64_t owner) {
5355 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(owner);
5356 CResult_PaymentSecretNoneZ_get_err(owner_conv);
5359 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
5360 CHECK(owner->result_ok);
5361 return ThirtyTwoBytes_clone(&*owner->contents.result);
5363 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_ok"))) TS_CResult_PaymentSecretAPIErrorZ_get_ok(uint64_t owner) {
5364 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(owner);
5365 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5366 memcpy(ret_arr->elems, CResult_PaymentSecretAPIErrorZ_get_ok(owner_conv).data, 32);
5370 static inline struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
5371 CHECK(!owner->result_ok);
5372 return APIError_clone(&*owner->contents.err);
5374 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_err"))) TS_CResult_PaymentSecretAPIErrorZ_get_err(uint64_t owner) {
5375 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(owner);
5376 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5377 *ret_copy = CResult_PaymentSecretAPIErrorZ_get_err(owner_conv);
5378 uint64_t ret_ref = tag_ptr(ret_copy, true);
5382 static inline struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
5383 CHECK(owner->result_ok);
5384 return ThirtyTwoBytes_clone(&*owner->contents.result);
5386 int8_tArray __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_get_ok(uint64_t owner) {
5387 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(owner);
5388 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5389 memcpy(ret_arr->elems, CResult_PaymentPreimageAPIErrorZ_get_ok(owner_conv).data, 32);
5393 static inline struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
5394 CHECK(!owner->result_ok);
5395 return APIError_clone(&*owner->contents.err);
5397 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_err"))) TS_CResult_PaymentPreimageAPIErrorZ_get_err(uint64_t owner) {
5398 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(owner);
5399 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5400 *ret_copy = CResult_PaymentPreimageAPIErrorZ_get_err(owner_conv);
5401 uint64_t ret_ref = tag_ptr(ret_copy, true);
5405 static inline struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5406 LDKCounterpartyForwardingInfo ret = *owner->contents.result;
5407 ret.is_owned = false;
5410 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(uint64_t owner) {
5411 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5412 LDKCounterpartyForwardingInfo ret_var = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner_conv);
5413 uint64_t ret_ref = 0;
5414 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5415 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5419 static inline struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5420 CHECK(!owner->result_ok);
5421 return DecodeError_clone(&*owner->contents.err);
5423 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(uint64_t owner) {
5424 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5425 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5426 *ret_copy = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner_conv);
5427 uint64_t ret_ref = tag_ptr(ret_copy, true);
5431 static inline struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5432 LDKChannelCounterparty ret = *owner->contents.result;
5433 ret.is_owned = false;
5436 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(uint64_t owner) {
5437 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5438 LDKChannelCounterparty ret_var = CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner_conv);
5439 uint64_t ret_ref = 0;
5440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5441 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5445 static inline struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5446 CHECK(!owner->result_ok);
5447 return DecodeError_clone(&*owner->contents.err);
5449 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(uint64_t owner) {
5450 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5451 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5452 *ret_copy = CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner_conv);
5453 uint64_t ret_ref = tag_ptr(ret_copy, true);
5457 static inline struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5458 LDKChannelDetails ret = *owner->contents.result;
5459 ret.is_owned = false;
5462 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(uint64_t owner) {
5463 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5464 LDKChannelDetails ret_var = CResult_ChannelDetailsDecodeErrorZ_get_ok(owner_conv);
5465 uint64_t ret_ref = 0;
5466 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5467 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5471 static inline struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5472 CHECK(!owner->result_ok);
5473 return DecodeError_clone(&*owner->contents.err);
5475 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_err(uint64_t owner) {
5476 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5477 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5478 *ret_copy = CResult_ChannelDetailsDecodeErrorZ_get_err(owner_conv);
5479 uint64_t ret_ref = tag_ptr(ret_copy, true);
5483 static inline struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5484 LDKPhantomRouteHints ret = *owner->contents.result;
5485 ret.is_owned = false;
5488 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(uint64_t owner) {
5489 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5490 LDKPhantomRouteHints ret_var = CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner_conv);
5491 uint64_t ret_ref = 0;
5492 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5493 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5497 static inline struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5498 CHECK(!owner->result_ok);
5499 return DecodeError_clone(&*owner->contents.err);
5501 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(uint64_t owner) {
5502 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5503 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5504 *ret_copy = CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner_conv);
5505 uint64_t ret_ref = tag_ptr(ret_copy, true);
5509 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
5510 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
5511 for (size_t i = 0; i < ret.datalen; i++) {
5512 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
5516 typedef struct LDKWatch_JCalls {
5517 atomic_size_t refcnt;
5518 uint32_t instance_ptr;
5520 static void LDKWatch_JCalls_free(void* this_arg) {
5521 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5522 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5526 LDKChannelMonitorUpdateStatus watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
5527 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5528 LDKOutPoint funding_txo_var = funding_txo;
5529 uint64_t funding_txo_ref = 0;
5530 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5531 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5532 LDKChannelMonitor monitor_var = monitor;
5533 uint64_t monitor_ref = 0;
5534 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
5535 monitor_ref = tag_ptr(monitor_var.inner, monitor_var.is_owned);
5536 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 17, funding_txo_ref, monitor_ref, 0, 0, 0, 0);
5537 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5540 LDKChannelMonitorUpdateStatus update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, const LDKChannelMonitorUpdate * update) {
5541 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5542 LDKOutPoint funding_txo_var = funding_txo;
5543 uint64_t funding_txo_ref = 0;
5544 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5545 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5546 LDKChannelMonitorUpdate update_var = *update;
5547 uint64_t update_ref = 0;
5548 update_var = ChannelMonitorUpdate_clone(&update_var);
5549 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
5550 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
5551 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 18, funding_txo_ref, update_ref, 0, 0, 0, 0);
5552 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5555 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
5556 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5557 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 19, 0, 0, 0, 0, 0, 0);
5558 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_constr;
5559 ret_constr.datalen = ret->arr_len;
5560 if (ret_constr.datalen > 0)
5561 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
5563 ret_constr.data = NULL;
5564 uint64_t* ret_vals = ret->elems;
5565 for (size_t x = 0; x < ret_constr.datalen; x++) {
5566 uint64_t ret_conv_49 = ret_vals[x];
5567 void* ret_conv_49_ptr = untag_ptr(ret_conv_49);
5568 CHECK_ACCESS(ret_conv_49_ptr);
5569 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ ret_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(ret_conv_49_ptr);
5570 FREE(untag_ptr(ret_conv_49));
5571 ret_constr.data[x] = ret_conv_49_conv;
5576 static void LDKWatch_JCalls_cloned(LDKWatch* new_obj) {
5577 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) new_obj->this_arg;
5578 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5580 static inline LDKWatch LDKWatch_init (JSValue o) {
5581 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
5582 atomic_init(&calls->refcnt, 1);
5583 calls->instance_ptr = o;
5586 .this_arg = (void*) calls,
5587 .watch_channel = watch_channel_LDKWatch_jcall,
5588 .update_channel = update_channel_LDKWatch_jcall,
5589 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
5590 .free = LDKWatch_JCalls_free,
5594 uint64_t __attribute__((export_name("TS_LDKWatch_new"))) TS_LDKWatch_new(JSValue o) {
5595 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
5596 *res_ptr = LDKWatch_init(o);
5597 return tag_ptr(res_ptr, true);
5599 uint32_t __attribute__((export_name("TS_Watch_watch_channel"))) TS_Watch_watch_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t monitor) {
5600 void* this_arg_ptr = untag_ptr(this_arg);
5601 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5602 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5603 LDKOutPoint funding_txo_conv;
5604 funding_txo_conv.inner = untag_ptr(funding_txo);
5605 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5606 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5607 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5608 LDKChannelMonitor monitor_conv;
5609 monitor_conv.inner = untag_ptr(monitor);
5610 monitor_conv.is_owned = ptr_is_owned(monitor);
5611 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
5612 monitor_conv = ChannelMonitor_clone(&monitor_conv);
5613 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv));
5617 uint32_t __attribute__((export_name("TS_Watch_update_channel"))) TS_Watch_update_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t update) {
5618 void* this_arg_ptr = untag_ptr(this_arg);
5619 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5620 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5621 LDKOutPoint funding_txo_conv;
5622 funding_txo_conv.inner = untag_ptr(funding_txo);
5623 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5624 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5625 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5626 LDKChannelMonitorUpdate update_conv;
5627 update_conv.inner = untag_ptr(update);
5628 update_conv.is_owned = ptr_is_owned(update);
5629 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
5630 update_conv.is_owned = false;
5631 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, &update_conv));
5635 uint64_tArray __attribute__((export_name("TS_Watch_release_pending_monitor_events"))) TS_Watch_release_pending_monitor_events(uint64_t this_arg) {
5636 void* this_arg_ptr = untag_ptr(this_arg);
5637 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5638 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5639 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
5640 uint64_tArray ret_arr = NULL;
5641 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
5642 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
5643 for (size_t x = 0; x < ret_var.datalen; x++) {
5644 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv_49_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
5645 *ret_conv_49_conv = ret_var.data[x];
5646 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
5653 typedef struct LDKBroadcasterInterface_JCalls {
5654 atomic_size_t refcnt;
5655 uint32_t instance_ptr;
5656 } LDKBroadcasterInterface_JCalls;
5657 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
5658 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5659 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5663 void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
5664 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5665 LDKTransaction tx_var = tx;
5666 int8_tArray tx_arr = init_int8_tArray(tx_var.datalen, __LINE__);
5667 memcpy(tx_arr->elems, tx_var.data, tx_var.datalen);
5668 Transaction_free(tx_var);
5669 js_invoke_function_uuuuuu(j_calls->instance_ptr, 20, (uint32_t)tx_arr, 0, 0, 0, 0, 0);
5671 static void LDKBroadcasterInterface_JCalls_cloned(LDKBroadcasterInterface* new_obj) {
5672 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) new_obj->this_arg;
5673 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5675 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JSValue o) {
5676 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
5677 atomic_init(&calls->refcnt, 1);
5678 calls->instance_ptr = o;
5680 LDKBroadcasterInterface ret = {
5681 .this_arg = (void*) calls,
5682 .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
5683 .free = LDKBroadcasterInterface_JCalls_free,
5687 uint64_t __attribute__((export_name("TS_LDKBroadcasterInterface_new"))) TS_LDKBroadcasterInterface_new(JSValue o) {
5688 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
5689 *res_ptr = LDKBroadcasterInterface_init(o);
5690 return tag_ptr(res_ptr, true);
5692 void __attribute__((export_name("TS_BroadcasterInterface_broadcast_transaction"))) TS_BroadcasterInterface_broadcast_transaction(uint64_t this_arg, int8_tArray tx) {
5693 void* this_arg_ptr = untag_ptr(this_arg);
5694 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5695 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)this_arg_ptr;
5696 LDKTransaction tx_ref;
5697 tx_ref.datalen = tx->arr_len;
5698 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
5699 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
5700 tx_ref.data_is_owned = true;
5701 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
5704 typedef struct LDKEntropySource_JCalls {
5705 atomic_size_t refcnt;
5706 uint32_t instance_ptr;
5707 } LDKEntropySource_JCalls;
5708 static void LDKEntropySource_JCalls_free(void* this_arg) {
5709 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) this_arg;
5710 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5714 LDKThirtyTwoBytes get_secure_random_bytes_LDKEntropySource_jcall(const void* this_arg) {
5715 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) this_arg;
5716 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 21, 0, 0, 0, 0, 0, 0);
5717 LDKThirtyTwoBytes ret_ref;
5718 CHECK(ret->arr_len == 32);
5719 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5722 static void LDKEntropySource_JCalls_cloned(LDKEntropySource* new_obj) {
5723 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) new_obj->this_arg;
5724 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5726 static inline LDKEntropySource LDKEntropySource_init (JSValue o) {
5727 LDKEntropySource_JCalls *calls = MALLOC(sizeof(LDKEntropySource_JCalls), "LDKEntropySource_JCalls");
5728 atomic_init(&calls->refcnt, 1);
5729 calls->instance_ptr = o;
5731 LDKEntropySource ret = {
5732 .this_arg = (void*) calls,
5733 .get_secure_random_bytes = get_secure_random_bytes_LDKEntropySource_jcall,
5734 .free = LDKEntropySource_JCalls_free,
5738 uint64_t __attribute__((export_name("TS_LDKEntropySource_new"))) TS_LDKEntropySource_new(JSValue o) {
5739 LDKEntropySource *res_ptr = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
5740 *res_ptr = LDKEntropySource_init(o);
5741 return tag_ptr(res_ptr, true);
5743 int8_tArray __attribute__((export_name("TS_EntropySource_get_secure_random_bytes"))) TS_EntropySource_get_secure_random_bytes(uint64_t this_arg) {
5744 void* this_arg_ptr = untag_ptr(this_arg);
5745 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5746 LDKEntropySource* this_arg_conv = (LDKEntropySource*)this_arg_ptr;
5747 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5748 memcpy(ret_arr->elems, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data, 32);
5752 uint32_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ty_from_ptr"))) TS_LDKUnsignedGossipMessage_ty_from_ptr(uint64_t ptr) {
5753 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5755 case LDKUnsignedGossipMessage_ChannelAnnouncement: return 0;
5756 case LDKUnsignedGossipMessage_ChannelUpdate: return 1;
5757 case LDKUnsignedGossipMessage_NodeAnnouncement: return 2;
5761 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement"))) TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(uint64_t ptr) {
5762 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5763 assert(obj->tag == LDKUnsignedGossipMessage_ChannelAnnouncement);
5764 LDKUnsignedChannelAnnouncement channel_announcement_var = obj->channel_announcement;
5765 uint64_t channel_announcement_ref = 0;
5766 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_announcement_var);
5767 channel_announcement_ref = tag_ptr(channel_announcement_var.inner, false);
5768 return channel_announcement_ref;
5770 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update"))) TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(uint64_t ptr) {
5771 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5772 assert(obj->tag == LDKUnsignedGossipMessage_ChannelUpdate);
5773 LDKUnsignedChannelUpdate channel_update_var = obj->channel_update;
5774 uint64_t channel_update_ref = 0;
5775 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_update_var);
5776 channel_update_ref = tag_ptr(channel_update_var.inner, false);
5777 return channel_update_ref;
5779 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement"))) TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(uint64_t ptr) {
5780 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5781 assert(obj->tag == LDKUnsignedGossipMessage_NodeAnnouncement);
5782 LDKUnsignedNodeAnnouncement node_announcement_var = obj->node_announcement;
5783 uint64_t node_announcement_ref = 0;
5784 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_announcement_var);
5785 node_announcement_ref = tag_ptr(node_announcement_var.inner, false);
5786 return node_announcement_ref;
5788 typedef struct LDKNodeSigner_JCalls {
5789 atomic_size_t refcnt;
5790 uint32_t instance_ptr;
5791 } LDKNodeSigner_JCalls;
5792 static void LDKNodeSigner_JCalls_free(void* this_arg) {
5793 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5794 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5798 LDKThirtyTwoBytes get_inbound_payment_key_material_LDKNodeSigner_jcall(const void* this_arg) {
5799 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5800 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 22, 0, 0, 0, 0, 0, 0);
5801 LDKThirtyTwoBytes ret_ref;
5802 CHECK(ret->arr_len == 32);
5803 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5806 LDKCResult_PublicKeyNoneZ get_node_id_LDKNodeSigner_jcall(const void* this_arg, LDKRecipient recipient) {
5807 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5808 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5809 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 23, recipient_conv, 0, 0, 0, 0, 0);
5810 void* ret_ptr = untag_ptr(ret);
5811 CHECK_ACCESS(ret_ptr);
5812 LDKCResult_PublicKeyNoneZ ret_conv = *(LDKCResult_PublicKeyNoneZ*)(ret_ptr);
5813 FREE(untag_ptr(ret));
5816 LDKCResult_SharedSecretNoneZ ecdh_LDKNodeSigner_jcall(const void* this_arg, LDKRecipient recipient, LDKPublicKey other_key, LDKCOption_ScalarZ tweak) {
5817 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5818 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5819 int8_tArray other_key_arr = init_int8_tArray(33, __LINE__);
5820 memcpy(other_key_arr->elems, other_key.compressed_form, 33);
5821 LDKCOption_ScalarZ *tweak_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
5822 *tweak_copy = tweak;
5823 uint64_t tweak_ref = tag_ptr(tweak_copy, true);
5824 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 24, recipient_conv, (uint32_t)other_key_arr, tweak_ref, 0, 0, 0);
5825 void* ret_ptr = untag_ptr(ret);
5826 CHECK_ACCESS(ret_ptr);
5827 LDKCResult_SharedSecretNoneZ ret_conv = *(LDKCResult_SharedSecretNoneZ*)(ret_ptr);
5828 FREE(untag_ptr(ret));
5831 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKNodeSigner_jcall(const void* this_arg, LDKu8slice hrp_bytes, LDKCVec_U5Z invoice_data, LDKRecipient recipient) {
5832 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5833 LDKu8slice hrp_bytes_var = hrp_bytes;
5834 int8_tArray hrp_bytes_arr = init_int8_tArray(hrp_bytes_var.datalen, __LINE__);
5835 memcpy(hrp_bytes_arr->elems, hrp_bytes_var.data, hrp_bytes_var.datalen);
5836 LDKCVec_U5Z invoice_data_var = invoice_data;
5837 ptrArray invoice_data_arr = NULL;
5838 invoice_data_arr = init_ptrArray(invoice_data_var.datalen, __LINE__);
5839 int8_t *invoice_data_arr_ptr = (int8_t*)(((uint8_t*)invoice_data_arr) + 8);
5840 for (size_t h = 0; h < invoice_data_var.datalen; h++) {
5841 uint8_t invoice_data_conv_7_val = invoice_data_var.data[h]._0;
5842 invoice_data_arr_ptr[h] = invoice_data_conv_7_val;
5845 FREE(invoice_data_var.data);
5846 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5847 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 25, (uint32_t)hrp_bytes_arr, (uint32_t)invoice_data_arr, recipient_conv, 0, 0, 0);
5848 void* ret_ptr = untag_ptr(ret);
5849 CHECK_ACCESS(ret_ptr);
5850 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
5851 FREE(untag_ptr(ret));
5854 LDKCResult_SignatureNoneZ sign_gossip_message_LDKNodeSigner_jcall(const void* this_arg, LDKUnsignedGossipMessage msg) {
5855 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5856 LDKUnsignedGossipMessage *msg_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
5858 uint64_t msg_ref = tag_ptr(msg_copy, true);
5859 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 26, msg_ref, 0, 0, 0, 0, 0);
5860 void* ret_ptr = untag_ptr(ret);
5861 CHECK_ACCESS(ret_ptr);
5862 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
5863 FREE(untag_ptr(ret));
5866 static void LDKNodeSigner_JCalls_cloned(LDKNodeSigner* new_obj) {
5867 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) new_obj->this_arg;
5868 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5870 static inline LDKNodeSigner LDKNodeSigner_init (JSValue o) {
5871 LDKNodeSigner_JCalls *calls = MALLOC(sizeof(LDKNodeSigner_JCalls), "LDKNodeSigner_JCalls");
5872 atomic_init(&calls->refcnt, 1);
5873 calls->instance_ptr = o;
5875 LDKNodeSigner ret = {
5876 .this_arg = (void*) calls,
5877 .get_inbound_payment_key_material = get_inbound_payment_key_material_LDKNodeSigner_jcall,
5878 .get_node_id = get_node_id_LDKNodeSigner_jcall,
5879 .ecdh = ecdh_LDKNodeSigner_jcall,
5880 .sign_invoice = sign_invoice_LDKNodeSigner_jcall,
5881 .sign_gossip_message = sign_gossip_message_LDKNodeSigner_jcall,
5882 .free = LDKNodeSigner_JCalls_free,
5886 uint64_t __attribute__((export_name("TS_LDKNodeSigner_new"))) TS_LDKNodeSigner_new(JSValue o) {
5887 LDKNodeSigner *res_ptr = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
5888 *res_ptr = LDKNodeSigner_init(o);
5889 return tag_ptr(res_ptr, true);
5891 int8_tArray __attribute__((export_name("TS_NodeSigner_get_inbound_payment_key_material"))) TS_NodeSigner_get_inbound_payment_key_material(uint64_t this_arg) {
5892 void* this_arg_ptr = untag_ptr(this_arg);
5893 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5894 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5895 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5896 memcpy(ret_arr->elems, (this_arg_conv->get_inbound_payment_key_material)(this_arg_conv->this_arg).data, 32);
5900 uint64_t __attribute__((export_name("TS_NodeSigner_get_node_id"))) TS_NodeSigner_get_node_id(uint64_t this_arg, uint32_t recipient) {
5901 void* this_arg_ptr = untag_ptr(this_arg);
5902 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5903 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5904 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5905 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
5906 *ret_conv = (this_arg_conv->get_node_id)(this_arg_conv->this_arg, recipient_conv);
5907 return tag_ptr(ret_conv, true);
5910 uint64_t __attribute__((export_name("TS_NodeSigner_ecdh"))) TS_NodeSigner_ecdh(uint64_t this_arg, uint32_t recipient, int8_tArray other_key, uint64_t tweak) {
5911 void* this_arg_ptr = untag_ptr(this_arg);
5912 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5913 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5914 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5915 LDKPublicKey other_key_ref;
5916 CHECK(other_key->arr_len == 33);
5917 memcpy(other_key_ref.compressed_form, other_key->elems, 33); FREE(other_key);
5918 void* tweak_ptr = untag_ptr(tweak);
5919 CHECK_ACCESS(tweak_ptr);
5920 LDKCOption_ScalarZ tweak_conv = *(LDKCOption_ScalarZ*)(tweak_ptr);
5921 tweak_conv = COption_ScalarZ_clone((LDKCOption_ScalarZ*)untag_ptr(tweak));
5922 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
5923 *ret_conv = (this_arg_conv->ecdh)(this_arg_conv->this_arg, recipient_conv, other_key_ref, tweak_conv);
5924 return tag_ptr(ret_conv, true);
5927 uint64_t __attribute__((export_name("TS_NodeSigner_sign_invoice"))) TS_NodeSigner_sign_invoice(uint64_t this_arg, int8_tArray hrp_bytes, ptrArray invoice_data, uint32_t recipient) {
5928 void* this_arg_ptr = untag_ptr(this_arg);
5929 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5930 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5931 LDKu8slice hrp_bytes_ref;
5932 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
5933 hrp_bytes_ref.data = hrp_bytes->elems;
5934 LDKCVec_U5Z invoice_data_constr;
5935 invoice_data_constr.datalen = invoice_data->arr_len;
5936 if (invoice_data_constr.datalen > 0)
5937 invoice_data_constr.data = MALLOC(invoice_data_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
5939 invoice_data_constr.data = NULL;
5940 int8_t* invoice_data_vals = (void*) invoice_data->elems;
5941 for (size_t h = 0; h < invoice_data_constr.datalen; h++) {
5942 int8_t invoice_data_conv_7 = invoice_data_vals[h];
5944 invoice_data_constr.data[h] = (LDKU5){ ._0 = invoice_data_conv_7 };
5947 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5948 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
5949 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, hrp_bytes_ref, invoice_data_constr, recipient_conv);
5951 return tag_ptr(ret_conv, true);
5954 uint64_t __attribute__((export_name("TS_NodeSigner_sign_gossip_message"))) TS_NodeSigner_sign_gossip_message(uint64_t this_arg, uint64_t msg) {
5955 void* this_arg_ptr = untag_ptr(this_arg);
5956 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5957 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5958 void* msg_ptr = untag_ptr(msg);
5959 CHECK_ACCESS(msg_ptr);
5960 LDKUnsignedGossipMessage msg_conv = *(LDKUnsignedGossipMessage*)(msg_ptr);
5961 msg_conv = UnsignedGossipMessage_clone((LDKUnsignedGossipMessage*)untag_ptr(msg));
5962 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
5963 *ret_conv = (this_arg_conv->sign_gossip_message)(this_arg_conv->this_arg, msg_conv);
5964 return tag_ptr(ret_conv, true);
5967 typedef struct LDKSignerProvider_JCalls {
5968 atomic_size_t refcnt;
5969 uint32_t instance_ptr;
5970 } LDKSignerProvider_JCalls;
5971 static void LDKSignerProvider_JCalls_free(void* this_arg) {
5972 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5973 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5977 LDKThirtyTwoBytes generate_channel_keys_id_LDKSignerProvider_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis, LDKU128 user_channel_id) {
5978 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5979 jboolean inbound_conv = inbound;
5980 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5981 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
5982 memcpy(user_channel_id_arr->elems, user_channel_id.le_bytes, 16);
5983 int8_tArray ret = (int8_tArray)js_invoke_function_ubuuuu(j_calls->instance_ptr, 27, inbound_conv, channel_value_satoshis_conv, (uint32_t)user_channel_id_arr, 0, 0, 0);
5984 LDKThirtyTwoBytes ret_ref;
5985 CHECK(ret->arr_len == 32);
5986 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5989 LDKWriteableEcdsaChannelSigner derive_channel_signer_LDKSignerProvider_jcall(const void* this_arg, uint64_t channel_value_satoshis, LDKThirtyTwoBytes channel_keys_id) {
5990 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5991 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5992 int8_tArray channel_keys_id_arr = init_int8_tArray(32, __LINE__);
5993 memcpy(channel_keys_id_arr->elems, channel_keys_id.data, 32);
5994 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 28, channel_value_satoshis_conv, (uint32_t)channel_keys_id_arr, 0, 0, 0, 0);
5995 void* ret_ptr = untag_ptr(ret);
5996 CHECK_ACCESS(ret_ptr);
5997 LDKWriteableEcdsaChannelSigner ret_conv = *(LDKWriteableEcdsaChannelSigner*)(ret_ptr);
5998 FREE(untag_ptr(ret));
6001 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer_LDKSignerProvider_jcall(const void* this_arg, LDKu8slice reader) {
6002 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
6003 LDKu8slice reader_var = reader;
6004 int8_tArray reader_arr = init_int8_tArray(reader_var.datalen, __LINE__);
6005 memcpy(reader_arr->elems, reader_var.data, reader_var.datalen);
6006 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 29, (uint32_t)reader_arr, 0, 0, 0, 0, 0);
6007 void* ret_ptr = untag_ptr(ret);
6008 CHECK_ACCESS(ret_ptr);
6009 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ ret_conv = *(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)(ret_ptr);
6010 FREE(untag_ptr(ret));
6013 LDKCVec_u8Z get_destination_script_LDKSignerProvider_jcall(const void* this_arg) {
6014 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
6015 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 30, 0, 0, 0, 0, 0, 0);
6016 LDKCVec_u8Z ret_ref;
6017 ret_ref.datalen = ret->arr_len;
6018 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6019 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6022 LDKShutdownScript get_shutdown_scriptpubkey_LDKSignerProvider_jcall(const void* this_arg) {
6023 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
6024 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 31, 0, 0, 0, 0, 0, 0);
6025 LDKShutdownScript ret_conv;
6026 ret_conv.inner = untag_ptr(ret);
6027 ret_conv.is_owned = ptr_is_owned(ret);
6028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
6031 static void LDKSignerProvider_JCalls_cloned(LDKSignerProvider* new_obj) {
6032 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) new_obj->this_arg;
6033 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6035 static inline LDKSignerProvider LDKSignerProvider_init (JSValue o) {
6036 LDKSignerProvider_JCalls *calls = MALLOC(sizeof(LDKSignerProvider_JCalls), "LDKSignerProvider_JCalls");
6037 atomic_init(&calls->refcnt, 1);
6038 calls->instance_ptr = o;
6040 LDKSignerProvider ret = {
6041 .this_arg = (void*) calls,
6042 .generate_channel_keys_id = generate_channel_keys_id_LDKSignerProvider_jcall,
6043 .derive_channel_signer = derive_channel_signer_LDKSignerProvider_jcall,
6044 .read_chan_signer = read_chan_signer_LDKSignerProvider_jcall,
6045 .get_destination_script = get_destination_script_LDKSignerProvider_jcall,
6046 .get_shutdown_scriptpubkey = get_shutdown_scriptpubkey_LDKSignerProvider_jcall,
6047 .free = LDKSignerProvider_JCalls_free,
6051 uint64_t __attribute__((export_name("TS_LDKSignerProvider_new"))) TS_LDKSignerProvider_new(JSValue o) {
6052 LDKSignerProvider *res_ptr = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
6053 *res_ptr = LDKSignerProvider_init(o);
6054 return tag_ptr(res_ptr, true);
6056 int8_tArray __attribute__((export_name("TS_SignerProvider_generate_channel_keys_id"))) TS_SignerProvider_generate_channel_keys_id(uint64_t this_arg, jboolean inbound, int64_t channel_value_satoshis, int8_tArray user_channel_id) {
6057 void* this_arg_ptr = untag_ptr(this_arg);
6058 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6059 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6060 LDKU128 user_channel_id_ref;
6061 CHECK(user_channel_id->arr_len == 16);
6062 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
6063 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6064 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);
6068 uint64_t __attribute__((export_name("TS_SignerProvider_derive_channel_signer"))) TS_SignerProvider_derive_channel_signer(uint64_t this_arg, int64_t channel_value_satoshis, int8_tArray channel_keys_id) {
6069 void* this_arg_ptr = untag_ptr(this_arg);
6070 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6071 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6072 LDKThirtyTwoBytes channel_keys_id_ref;
6073 CHECK(channel_keys_id->arr_len == 32);
6074 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
6075 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
6076 *ret_ret = (this_arg_conv->derive_channel_signer)(this_arg_conv->this_arg, channel_value_satoshis, channel_keys_id_ref);
6077 return tag_ptr(ret_ret, true);
6080 uint64_t __attribute__((export_name("TS_SignerProvider_read_chan_signer"))) TS_SignerProvider_read_chan_signer(uint64_t this_arg, int8_tArray reader) {
6081 void* this_arg_ptr = untag_ptr(this_arg);
6082 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6083 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6084 LDKu8slice reader_ref;
6085 reader_ref.datalen = reader->arr_len;
6086 reader_ref.data = reader->elems;
6087 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
6088 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
6090 return tag_ptr(ret_conv, true);
6093 int8_tArray __attribute__((export_name("TS_SignerProvider_get_destination_script"))) TS_SignerProvider_get_destination_script(uint64_t this_arg) {
6094 void* this_arg_ptr = untag_ptr(this_arg);
6095 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6096 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6097 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
6098 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6099 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6100 CVec_u8Z_free(ret_var);
6104 uint64_t __attribute__((export_name("TS_SignerProvider_get_shutdown_scriptpubkey"))) TS_SignerProvider_get_shutdown_scriptpubkey(uint64_t this_arg) {
6105 void* this_arg_ptr = untag_ptr(this_arg);
6106 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6107 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6108 LDKShutdownScript ret_var = (this_arg_conv->get_shutdown_scriptpubkey)(this_arg_conv->this_arg);
6109 uint64_t ret_ref = 0;
6110 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6111 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6115 typedef struct LDKFeeEstimator_JCalls {
6116 atomic_size_t refcnt;
6117 uint32_t instance_ptr;
6118 } LDKFeeEstimator_JCalls;
6119 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
6120 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
6121 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6125 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
6126 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
6127 uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
6128 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 32, confirmation_target_conv, 0, 0, 0, 0, 0);
6130 static void LDKFeeEstimator_JCalls_cloned(LDKFeeEstimator* new_obj) {
6131 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) new_obj->this_arg;
6132 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6134 static inline LDKFeeEstimator LDKFeeEstimator_init (JSValue o) {
6135 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
6136 atomic_init(&calls->refcnt, 1);
6137 calls->instance_ptr = o;
6139 LDKFeeEstimator ret = {
6140 .this_arg = (void*) calls,
6141 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
6142 .free = LDKFeeEstimator_JCalls_free,
6146 uint64_t __attribute__((export_name("TS_LDKFeeEstimator_new"))) TS_LDKFeeEstimator_new(JSValue o) {
6147 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
6148 *res_ptr = LDKFeeEstimator_init(o);
6149 return tag_ptr(res_ptr, true);
6151 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) {
6152 void* this_arg_ptr = untag_ptr(this_arg);
6153 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6154 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)this_arg_ptr;
6155 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_js(confirmation_target);
6156 int32_t ret_conv = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
6160 typedef struct LDKRouter_JCalls {
6161 atomic_size_t refcnt;
6162 uint32_t instance_ptr;
6164 static void LDKRouter_JCalls_free(void* this_arg) {
6165 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
6166 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6170 LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, const LDKInFlightHtlcs * inflight_htlcs) {
6171 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
6172 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
6173 memcpy(payer_arr->elems, payer.compressed_form, 33);
6174 LDKRouteParameters route_params_var = *route_params;
6175 uint64_t route_params_ref = 0;
6176 route_params_var = RouteParameters_clone(&route_params_var);
6177 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
6178 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
6179 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
6180 uint64_tArray first_hops_arr = NULL;
6181 if (first_hops != NULL) {
6182 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
6183 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
6184 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
6185 for (size_t q = 0; q < first_hops_var.datalen; q++) {
6186 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
6187 uint64_t first_hops_conv_16_ref = 0;
6188 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
6189 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
6190 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
6194 LDKInFlightHtlcs inflight_htlcs_var = *inflight_htlcs;
6195 uint64_t inflight_htlcs_ref = 0;
6196 inflight_htlcs_var = InFlightHtlcs_clone(&inflight_htlcs_var);
6197 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
6198 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
6199 uint64_t ret = js_invoke_function_ububuu(j_calls->instance_ptr, 33, (uint32_t)payer_arr, route_params_ref, (uint32_t)first_hops_arr, inflight_htlcs_ref, 0, 0);
6200 void* ret_ptr = untag_ptr(ret);
6201 CHECK_ACCESS(ret_ptr);
6202 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
6203 FREE(untag_ptr(ret));
6206 LDKCResult_RouteLightningErrorZ find_route_with_id_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, const LDKInFlightHtlcs * inflight_htlcs, LDKThirtyTwoBytes _payment_hash, LDKThirtyTwoBytes _payment_id) {
6207 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
6208 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
6209 memcpy(payer_arr->elems, payer.compressed_form, 33);
6210 LDKRouteParameters route_params_var = *route_params;
6211 uint64_t route_params_ref = 0;
6212 route_params_var = RouteParameters_clone(&route_params_var);
6213 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
6214 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
6215 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
6216 uint64_tArray first_hops_arr = NULL;
6217 if (first_hops != NULL) {
6218 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
6219 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
6220 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
6221 for (size_t q = 0; q < first_hops_var.datalen; q++) {
6222 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
6223 uint64_t first_hops_conv_16_ref = 0;
6224 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
6225 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
6226 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
6230 LDKInFlightHtlcs inflight_htlcs_var = *inflight_htlcs;
6231 uint64_t inflight_htlcs_ref = 0;
6232 inflight_htlcs_var = InFlightHtlcs_clone(&inflight_htlcs_var);
6233 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
6234 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
6235 int8_tArray _payment_hash_arr = init_int8_tArray(32, __LINE__);
6236 memcpy(_payment_hash_arr->elems, _payment_hash.data, 32);
6237 int8_tArray _payment_id_arr = init_int8_tArray(32, __LINE__);
6238 memcpy(_payment_id_arr->elems, _payment_id.data, 32);
6239 uint64_t ret = js_invoke_function_ububuu(j_calls->instance_ptr, 34, (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);
6240 void* ret_ptr = untag_ptr(ret);
6241 CHECK_ACCESS(ret_ptr);
6242 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
6243 FREE(untag_ptr(ret));
6246 static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
6247 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) new_obj->this_arg;
6248 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6250 static inline LDKRouter LDKRouter_init (JSValue o) {
6251 LDKRouter_JCalls *calls = MALLOC(sizeof(LDKRouter_JCalls), "LDKRouter_JCalls");
6252 atomic_init(&calls->refcnt, 1);
6253 calls->instance_ptr = o;
6256 .this_arg = (void*) calls,
6257 .find_route = find_route_LDKRouter_jcall,
6258 .find_route_with_id = find_route_with_id_LDKRouter_jcall,
6259 .free = LDKRouter_JCalls_free,
6263 uint64_t __attribute__((export_name("TS_LDKRouter_new"))) TS_LDKRouter_new(JSValue o) {
6264 LDKRouter *res_ptr = MALLOC(sizeof(LDKRouter), "LDKRouter");
6265 *res_ptr = LDKRouter_init(o);
6266 return tag_ptr(res_ptr, true);
6268 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) {
6269 void* this_arg_ptr = untag_ptr(this_arg);
6270 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6271 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
6272 LDKPublicKey payer_ref;
6273 CHECK(payer->arr_len == 33);
6274 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
6275 LDKRouteParameters route_params_conv;
6276 route_params_conv.inner = untag_ptr(route_params);
6277 route_params_conv.is_owned = ptr_is_owned(route_params);
6278 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
6279 route_params_conv.is_owned = false;
6280 LDKCVec_ChannelDetailsZ first_hops_constr;
6281 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
6282 if (first_hops != 0) {
6283 first_hops_constr.datalen = first_hops->arr_len;
6284 if (first_hops_constr.datalen > 0)
6285 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
6287 first_hops_constr.data = NULL;
6288 uint64_t* first_hops_vals = first_hops->elems;
6289 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
6290 uint64_t first_hops_conv_16 = first_hops_vals[q];
6291 LDKChannelDetails first_hops_conv_16_conv;
6292 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
6293 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
6294 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
6295 first_hops_conv_16_conv.is_owned = false;
6296 first_hops_constr.data[q] = first_hops_conv_16_conv;
6299 first_hops_ptr = &first_hops_constr;
6301 LDKInFlightHtlcs inflight_htlcs_conv;
6302 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
6303 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
6304 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
6305 inflight_htlcs_conv.is_owned = false;
6306 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
6307 *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, first_hops_ptr, &inflight_htlcs_conv);
6308 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
6309 return tag_ptr(ret_conv, true);
6312 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) {
6313 void* this_arg_ptr = untag_ptr(this_arg);
6314 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6315 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
6316 LDKPublicKey payer_ref;
6317 CHECK(payer->arr_len == 33);
6318 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
6319 LDKRouteParameters route_params_conv;
6320 route_params_conv.inner = untag_ptr(route_params);
6321 route_params_conv.is_owned = ptr_is_owned(route_params);
6322 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
6323 route_params_conv.is_owned = false;
6324 LDKCVec_ChannelDetailsZ first_hops_constr;
6325 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
6326 if (first_hops != 0) {
6327 first_hops_constr.datalen = first_hops->arr_len;
6328 if (first_hops_constr.datalen > 0)
6329 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
6331 first_hops_constr.data = NULL;
6332 uint64_t* first_hops_vals = first_hops->elems;
6333 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
6334 uint64_t first_hops_conv_16 = first_hops_vals[q];
6335 LDKChannelDetails first_hops_conv_16_conv;
6336 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
6337 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
6338 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
6339 first_hops_conv_16_conv.is_owned = false;
6340 first_hops_constr.data[q] = first_hops_conv_16_conv;
6343 first_hops_ptr = &first_hops_constr;
6345 LDKInFlightHtlcs inflight_htlcs_conv;
6346 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
6347 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
6348 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
6349 inflight_htlcs_conv.is_owned = false;
6350 LDKThirtyTwoBytes _payment_hash_ref;
6351 CHECK(_payment_hash->arr_len == 32);
6352 memcpy(_payment_hash_ref.data, _payment_hash->elems, 32); FREE(_payment_hash);
6353 LDKThirtyTwoBytes _payment_id_ref;
6354 CHECK(_payment_id->arr_len == 32);
6355 memcpy(_payment_id_ref.data, _payment_id->elems, 32); FREE(_payment_id);
6356 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
6357 *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);
6358 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
6359 return tag_ptr(ret_conv, true);
6362 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
6363 return ThirtyTwoBytes_clone(&owner->a);
6365 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_a"))) TS_C2Tuple_BlockHashChannelManagerZ_get_a(uint64_t owner) {
6366 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)untag_ptr(owner);
6367 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6368 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelManagerZ_get_a(owner_conv).data, 32);
6372 static inline struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
6373 LDKChannelManager ret = owner->b;
6374 ret.is_owned = false;
6377 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_b"))) TS_C2Tuple_BlockHashChannelManagerZ_get_b(uint64_t owner) {
6378 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)untag_ptr(owner);
6379 LDKChannelManager ret_var = C2Tuple_BlockHashChannelManagerZ_get_b(owner_conv);
6380 uint64_t ret_ref = 0;
6381 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6382 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6386 static inline struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
6387 CHECK(owner->result_ok);
6388 return &*owner->contents.result;
6390 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint64_t owner) {
6391 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(owner);
6392 uint64_t ret_ret = tag_ptr(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner_conv), false);
6396 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
6397 CHECK(!owner->result_ok);
6398 return DecodeError_clone(&*owner->contents.err);
6400 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(uint64_t owner) {
6401 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(owner);
6402 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6403 *ret_copy = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner_conv);
6404 uint64_t ret_ref = tag_ptr(ret_copy, true);
6408 static inline struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
6409 LDKChannelConfig ret = *owner->contents.result;
6410 ret.is_owned = false;
6413 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_get_ok(uint64_t owner) {
6414 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
6415 LDKChannelConfig ret_var = CResult_ChannelConfigDecodeErrorZ_get_ok(owner_conv);
6416 uint64_t ret_ref = 0;
6417 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6418 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6422 static inline struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
6423 CHECK(!owner->result_ok);
6424 return DecodeError_clone(&*owner->contents.err);
6426 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_err"))) TS_CResult_ChannelConfigDecodeErrorZ_get_err(uint64_t owner) {
6427 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
6428 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6429 *ret_copy = CResult_ChannelConfigDecodeErrorZ_get_err(owner_conv);
6430 uint64_t ret_ref = tag_ptr(ret_copy, true);
6434 uint32_t __attribute__((export_name("TS_LDKCOption_APIErrorZ_ty_from_ptr"))) TS_LDKCOption_APIErrorZ_ty_from_ptr(uint64_t ptr) {
6435 LDKCOption_APIErrorZ *obj = (LDKCOption_APIErrorZ*)untag_ptr(ptr);
6437 case LDKCOption_APIErrorZ_Some: return 0;
6438 case LDKCOption_APIErrorZ_None: return 1;
6442 uint64_t __attribute__((export_name("TS_LDKCOption_APIErrorZ_Some_get_some"))) TS_LDKCOption_APIErrorZ_Some_get_some(uint64_t ptr) {
6443 LDKCOption_APIErrorZ *obj = (LDKCOption_APIErrorZ*)untag_ptr(ptr);
6444 assert(obj->tag == LDKCOption_APIErrorZ_Some);
6445 uint64_t some_ref = tag_ptr(&obj->some, false);
6448 static inline struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner){
6449 CHECK(owner->result_ok);
6450 return COption_APIErrorZ_clone(&*owner->contents.result);
6452 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(uint64_t owner) {
6453 LDKCResult_COption_APIErrorZDecodeErrorZ* owner_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(owner);
6454 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
6455 *ret_copy = CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner_conv);
6456 uint64_t ret_ref = tag_ptr(ret_copy, true);
6460 static inline struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner){
6461 CHECK(!owner->result_ok);
6462 return DecodeError_clone(&*owner->contents.err);
6464 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_get_err"))) TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(uint64_t owner) {
6465 LDKCResult_COption_APIErrorZDecodeErrorZ* owner_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(owner);
6466 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6467 *ret_copy = CResult_COption_APIErrorZDecodeErrorZ_get_err(owner_conv);
6468 uint64_t ret_ref = tag_ptr(ret_copy, true);
6472 static inline struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner){
6473 LDKUntrustedString ret = *owner->contents.result;
6474 ret.is_owned = false;
6477 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_get_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_get_ok(uint64_t owner) {
6478 LDKCResult_UntrustedStringDecodeErrorZ* owner_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(owner);
6479 LDKUntrustedString ret_var = CResult_UntrustedStringDecodeErrorZ_get_ok(owner_conv);
6480 uint64_t ret_ref = 0;
6481 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6482 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6486 static inline struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner){
6487 CHECK(!owner->result_ok);
6488 return DecodeError_clone(&*owner->contents.err);
6490 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_get_err"))) TS_CResult_UntrustedStringDecodeErrorZ_get_err(uint64_t owner) {
6491 LDKCResult_UntrustedStringDecodeErrorZ* owner_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(owner);
6492 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6493 *ret_copy = CResult_UntrustedStringDecodeErrorZ_get_err(owner_conv);
6494 uint64_t ret_ref = tag_ptr(ret_copy, true);
6498 static inline struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
6499 LDKOutPoint ret = *owner->contents.result;
6500 ret.is_owned = false;
6503 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_ok"))) TS_CResult_OutPointDecodeErrorZ_get_ok(uint64_t owner) {
6504 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
6505 LDKOutPoint ret_var = CResult_OutPointDecodeErrorZ_get_ok(owner_conv);
6506 uint64_t ret_ref = 0;
6507 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6508 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6512 static inline struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
6513 CHECK(!owner->result_ok);
6514 return DecodeError_clone(&*owner->contents.err);
6516 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_err"))) TS_CResult_OutPointDecodeErrorZ_get_err(uint64_t owner) {
6517 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
6518 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6519 *ret_copy = CResult_OutPointDecodeErrorZ_get_err(owner_conv);
6520 uint64_t ret_ref = tag_ptr(ret_copy, true);
6524 typedef struct LDKType_JCalls {
6525 atomic_size_t refcnt;
6526 uint32_t instance_ptr;
6528 static void LDKType_JCalls_free(void* this_arg) {
6529 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6530 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6534 uint16_t type_id_LDKType_jcall(const void* this_arg) {
6535 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6536 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 35, 0, 0, 0, 0, 0, 0);
6538 LDKStr debug_str_LDKType_jcall(const void* this_arg) {
6539 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6540 jstring ret = (jstring)js_invoke_function_uuuuuu(j_calls->instance_ptr, 36, 0, 0, 0, 0, 0, 0);
6541 LDKStr ret_conv = str_ref_to_owned_c(ret);
6544 LDKCVec_u8Z write_LDKType_jcall(const void* this_arg) {
6545 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6546 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 37, 0, 0, 0, 0, 0, 0);
6547 LDKCVec_u8Z ret_ref;
6548 ret_ref.datalen = ret->arr_len;
6549 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6550 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6553 static void LDKType_JCalls_cloned(LDKType* new_obj) {
6554 LDKType_JCalls *j_calls = (LDKType_JCalls*) new_obj->this_arg;
6555 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6557 static inline LDKType LDKType_init (JSValue o) {
6558 LDKType_JCalls *calls = MALLOC(sizeof(LDKType_JCalls), "LDKType_JCalls");
6559 atomic_init(&calls->refcnt, 1);
6560 calls->instance_ptr = o;
6563 .this_arg = (void*) calls,
6564 .type_id = type_id_LDKType_jcall,
6565 .debug_str = debug_str_LDKType_jcall,
6566 .write = write_LDKType_jcall,
6567 .cloned = LDKType_JCalls_cloned,
6568 .free = LDKType_JCalls_free,
6572 uint64_t __attribute__((export_name("TS_LDKType_new"))) TS_LDKType_new(JSValue o) {
6573 LDKType *res_ptr = MALLOC(sizeof(LDKType), "LDKType");
6574 *res_ptr = LDKType_init(o);
6575 return tag_ptr(res_ptr, true);
6577 int16_t __attribute__((export_name("TS_Type_type_id"))) TS_Type_type_id(uint64_t this_arg) {
6578 void* this_arg_ptr = untag_ptr(this_arg);
6579 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6580 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6581 int16_t ret_conv = (this_arg_conv->type_id)(this_arg_conv->this_arg);
6585 jstring __attribute__((export_name("TS_Type_debug_str"))) TS_Type_debug_str(uint64_t this_arg) {
6586 void* this_arg_ptr = untag_ptr(this_arg);
6587 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6588 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6589 LDKStr ret_str = (this_arg_conv->debug_str)(this_arg_conv->this_arg);
6590 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6595 int8_tArray __attribute__((export_name("TS_Type_write"))) TS_Type_write(uint64_t this_arg) {
6596 void* this_arg_ptr = untag_ptr(this_arg);
6597 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6598 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6599 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
6600 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6601 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6602 CVec_u8Z_free(ret_var);
6606 uint32_t __attribute__((export_name("TS_LDKCOption_TypeZ_ty_from_ptr"))) TS_LDKCOption_TypeZ_ty_from_ptr(uint64_t ptr) {
6607 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
6609 case LDKCOption_TypeZ_Some: return 0;
6610 case LDKCOption_TypeZ_None: return 1;
6614 uint64_t __attribute__((export_name("TS_LDKCOption_TypeZ_Some_get_some"))) TS_LDKCOption_TypeZ_Some_get_some(uint64_t ptr) {
6615 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
6616 assert(obj->tag == LDKCOption_TypeZ_Some);
6617 LDKType* some_ret = MALLOC(sizeof(LDKType), "LDKType");
6618 *some_ret = Type_clone(&obj->some);
6619 return tag_ptr(some_ret, true);
6621 static inline struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
6622 CHECK(owner->result_ok);
6623 return COption_TypeZ_clone(&*owner->contents.result);
6625 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_get_ok(uint64_t owner) {
6626 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
6627 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
6628 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_ok(owner_conv);
6629 uint64_t ret_ref = tag_ptr(ret_copy, true);
6633 static inline struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
6634 CHECK(!owner->result_ok);
6635 return DecodeError_clone(&*owner->contents.err);
6637 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_err"))) TS_CResult_COption_TypeZDecodeErrorZ_get_err(uint64_t owner) {
6638 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
6639 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6640 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_err(owner_conv);
6641 uint64_t ret_ref = tag_ptr(ret_copy, true);
6645 uint32_t __attribute__((export_name("TS_LDKPaymentError_ty_from_ptr"))) TS_LDKPaymentError_ty_from_ptr(uint64_t ptr) {
6646 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
6648 case LDKPaymentError_Invoice: return 0;
6649 case LDKPaymentError_Sending: return 1;
6653 jstring __attribute__((export_name("TS_LDKPaymentError_Invoice_get_invoice"))) TS_LDKPaymentError_Invoice_get_invoice(uint64_t ptr) {
6654 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
6655 assert(obj->tag == LDKPaymentError_Invoice);
6656 LDKStr invoice_str = obj->invoice;
6657 jstring invoice_conv = str_ref_to_ts(invoice_str.chars, invoice_str.len);
6658 return invoice_conv;
6660 uint32_t __attribute__((export_name("TS_LDKPaymentError_Sending_get_sending"))) TS_LDKPaymentError_Sending_get_sending(uint64_t ptr) {
6661 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
6662 assert(obj->tag == LDKPaymentError_Sending);
6663 uint32_t sending_conv = LDKRetryableSendFailure_to_js(obj->sending);
6664 return sending_conv;
6666 static inline struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
6667 CHECK(owner->result_ok);
6668 return ThirtyTwoBytes_clone(&*owner->contents.result);
6670 int8_tArray __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_ok"))) TS_CResult_PaymentIdPaymentErrorZ_get_ok(uint64_t owner) {
6671 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(owner);
6672 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6673 memcpy(ret_arr->elems, CResult_PaymentIdPaymentErrorZ_get_ok(owner_conv).data, 32);
6677 static inline struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
6678 CHECK(!owner->result_ok);
6679 return PaymentError_clone(&*owner->contents.err);
6681 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_err"))) TS_CResult_PaymentIdPaymentErrorZ_get_err(uint64_t owner) {
6682 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(owner);
6683 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
6684 *ret_copy = CResult_PaymentIdPaymentErrorZ_get_err(owner_conv);
6685 uint64_t ret_ref = tag_ptr(ret_copy, true);
6689 static inline void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
6690 CHECK(owner->result_ok);
6691 return *owner->contents.result;
6693 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_ok"))) TS_CResult_NonePaymentErrorZ_get_ok(uint64_t owner) {
6694 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
6695 CResult_NonePaymentErrorZ_get_ok(owner_conv);
6698 static inline struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
6699 CHECK(!owner->result_ok);
6700 return PaymentError_clone(&*owner->contents.err);
6702 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_err"))) TS_CResult_NonePaymentErrorZ_get_err(uint64_t owner) {
6703 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
6704 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
6705 *ret_copy = CResult_NonePaymentErrorZ_get_err(owner_conv);
6706 uint64_t ret_ref = tag_ptr(ret_copy, true);
6710 static inline struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner){
6711 CHECK(owner->result_ok);
6712 return *owner->contents.result;
6714 jstring __attribute__((export_name("TS_CResult_StringErrorZ_get_ok"))) TS_CResult_StringErrorZ_get_ok(uint64_t owner) {
6715 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)untag_ptr(owner);
6716 LDKStr ret_str = CResult_StringErrorZ_get_ok(owner_conv);
6717 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6721 static inline enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner){
6722 CHECK(!owner->result_ok);
6723 return *owner->contents.err;
6725 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_get_err"))) TS_CResult_StringErrorZ_get_err(uint64_t owner) {
6726 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)untag_ptr(owner);
6727 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_StringErrorZ_get_err(owner_conv));
6731 static inline struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6732 LDKChannelMonitorUpdate ret = *owner->contents.result;
6733 ret.is_owned = false;
6736 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6737 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6738 LDKChannelMonitorUpdate ret_var = CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner_conv);
6739 uint64_t ret_ref = 0;
6740 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6741 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6745 static inline struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6746 CHECK(!owner->result_ok);
6747 return DecodeError_clone(&*owner->contents.err);
6749 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(uint64_t owner) {
6750 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6751 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6752 *ret_copy = CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner_conv);
6753 uint64_t ret_ref = tag_ptr(ret_copy, true);
6757 uint32_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_ty_from_ptr"))) TS_LDKCOption_MonitorEventZ_ty_from_ptr(uint64_t ptr) {
6758 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6760 case LDKCOption_MonitorEventZ_Some: return 0;
6761 case LDKCOption_MonitorEventZ_None: return 1;
6765 uint64_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_Some_get_some"))) TS_LDKCOption_MonitorEventZ_Some_get_some(uint64_t ptr) {
6766 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6767 assert(obj->tag == LDKCOption_MonitorEventZ_Some);
6768 uint64_t some_ref = tag_ptr(&obj->some, false);
6771 static inline struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6772 CHECK(owner->result_ok);
6773 return COption_MonitorEventZ_clone(&*owner->contents.result);
6775 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint64_t owner) {
6776 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6777 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
6778 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner_conv);
6779 uint64_t ret_ref = tag_ptr(ret_copy, true);
6783 static inline struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6784 CHECK(!owner->result_ok);
6785 return DecodeError_clone(&*owner->contents.err);
6787 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(uint64_t owner) {
6788 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6789 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6790 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner_conv);
6791 uint64_t ret_ref = tag_ptr(ret_copy, true);
6795 static inline struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6796 LDKHTLCUpdate ret = *owner->contents.result;
6797 ret.is_owned = false;
6800 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6801 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6802 LDKHTLCUpdate ret_var = CResult_HTLCUpdateDecodeErrorZ_get_ok(owner_conv);
6803 uint64_t ret_ref = 0;
6804 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6805 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6809 static inline struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6810 CHECK(!owner->result_ok);
6811 return DecodeError_clone(&*owner->contents.err);
6813 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_err(uint64_t owner) {
6814 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6815 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6816 *ret_copy = CResult_HTLCUpdateDecodeErrorZ_get_err(owner_conv);
6817 uint64_t ret_ref = tag_ptr(ret_copy, true);
6821 static inline struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6822 LDKOutPoint ret = owner->a;
6823 ret.is_owned = false;
6826 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_a"))) TS_C2Tuple_OutPointScriptZ_get_a(uint64_t owner) {
6827 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(owner);
6828 LDKOutPoint ret_var = C2Tuple_OutPointScriptZ_get_a(owner_conv);
6829 uint64_t ret_ref = 0;
6830 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6831 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6835 static inline struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6836 return CVec_u8Z_clone(&owner->b);
6838 int8_tArray __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_b"))) TS_C2Tuple_OutPointScriptZ_get_b(uint64_t owner) {
6839 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(owner);
6840 LDKCVec_u8Z ret_var = C2Tuple_OutPointScriptZ_get_b(owner_conv);
6841 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6842 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6843 CVec_u8Z_free(ret_var);
6847 static inline uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6850 int32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_a"))) TS_C2Tuple_u32ScriptZ_get_a(uint64_t owner) {
6851 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(owner);
6852 int32_t ret_conv = C2Tuple_u32ScriptZ_get_a(owner_conv);
6856 static inline struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6857 return CVec_u8Z_clone(&owner->b);
6859 int8_tArray __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_b"))) TS_C2Tuple_u32ScriptZ_get_b(uint64_t owner) {
6860 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(owner);
6861 LDKCVec_u8Z ret_var = C2Tuple_u32ScriptZ_get_b(owner_conv);
6862 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6863 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6864 CVec_u8Z_free(ret_var);
6868 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
6869 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
6870 for (size_t i = 0; i < ret.datalen; i++) {
6871 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
6875 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6876 return ThirtyTwoBytes_clone(&owner->a);
6878 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint64_t owner) {
6879 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(owner);
6880 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6881 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner_conv).data, 32);
6885 static inline struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6886 return CVec_C2Tuple_u32ScriptZZ_clone(&owner->b);
6888 uint64_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint64_t owner) {
6889 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(owner);
6890 LDKCVec_C2Tuple_u32ScriptZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner_conv);
6891 uint64_tArray ret_arr = NULL;
6892 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6893 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6894 for (size_t v = 0; v < ret_var.datalen; v++) {
6895 LDKC2Tuple_u32ScriptZ* ret_conv_21_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
6896 *ret_conv_21_conv = ret_var.data[v];
6897 ret_arr_ptr[v] = tag_ptr(ret_conv_21_conv, true);
6904 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
6905 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 };
6906 for (size_t i = 0; i < ret.datalen; i++) {
6907 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(&orig->data[i]);
6911 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
6912 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
6913 for (size_t i = 0; i < ret.datalen; i++) {
6914 ret.data[i] = Event_clone(&orig->data[i]);
6918 static inline uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6921 int32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_a"))) TS_C2Tuple_u32TxOutZ_get_a(uint64_t owner) {
6922 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6923 int32_t ret_conv = C2Tuple_u32TxOutZ_get_a(owner_conv);
6927 static inline struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6928 return TxOut_clone(&owner->b);
6930 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_b"))) TS_C2Tuple_u32TxOutZ_get_b(uint64_t owner) {
6931 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6932 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6933 *ret_ref = C2Tuple_u32TxOutZ_get_b(owner_conv);
6934 return tag_ptr(ret_ref, true);
6937 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
6938 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
6939 for (size_t i = 0; i < ret.datalen; i++) {
6940 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
6944 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6945 return ThirtyTwoBytes_clone(&owner->a);
6947 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint64_t owner) {
6948 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6949 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6950 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner_conv).data, 32);
6954 static inline struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6955 return CVec_C2Tuple_u32TxOutZZ_clone(&owner->b);
6957 uint64_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint64_t owner) {
6958 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6959 LDKCVec_C2Tuple_u32TxOutZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner_conv);
6960 uint64_tArray ret_arr = NULL;
6961 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6962 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6963 for (size_t u = 0; u < ret_var.datalen; u++) {
6964 LDKC2Tuple_u32TxOutZ* ret_conv_20_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
6965 *ret_conv_20_conv = ret_var.data[u];
6966 ret_arr_ptr[u] = tag_ptr(ret_conv_20_conv, true);
6973 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
6974 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 };
6975 for (size_t i = 0; i < ret.datalen; i++) {
6976 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
6980 uint32_t __attribute__((export_name("TS_LDKBalance_ty_from_ptr"))) TS_LDKBalance_ty_from_ptr(uint64_t ptr) {
6981 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6983 case LDKBalance_ClaimableOnChannelClose: return 0;
6984 case LDKBalance_ClaimableAwaitingConfirmations: return 1;
6985 case LDKBalance_ContentiousClaimable: return 2;
6986 case LDKBalance_MaybeTimeoutClaimableHTLC: return 3;
6987 case LDKBalance_MaybePreimageClaimableHTLC: return 4;
6988 case LDKBalance_CounterpartyRevokedOutputClaimable: return 5;
6992 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(uint64_t ptr) {
6993 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6994 assert(obj->tag == LDKBalance_ClaimableOnChannelClose);
6995 int64_t claimable_amount_satoshis_conv = obj->claimable_on_channel_close.claimable_amount_satoshis;
6996 return claimable_amount_satoshis_conv;
6998 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(uint64_t ptr) {
6999 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7000 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
7001 int64_t claimable_amount_satoshis_conv = obj->claimable_awaiting_confirmations.claimable_amount_satoshis;
7002 return claimable_amount_satoshis_conv;
7004 int32_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(uint64_t ptr) {
7005 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7006 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
7007 int32_t confirmation_height_conv = obj->claimable_awaiting_confirmations.confirmation_height;
7008 return confirmation_height_conv;
7010 int64_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(uint64_t ptr) {
7011 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7012 assert(obj->tag == LDKBalance_ContentiousClaimable);
7013 int64_t claimable_amount_satoshis_conv = obj->contentious_claimable.claimable_amount_satoshis;
7014 return claimable_amount_satoshis_conv;
7016 int32_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_timeout_height"))) TS_LDKBalance_ContentiousClaimable_get_timeout_height(uint64_t ptr) {
7017 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7018 assert(obj->tag == LDKBalance_ContentiousClaimable);
7019 int32_t timeout_height_conv = obj->contentious_claimable.timeout_height;
7020 return timeout_height_conv;
7022 int64_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(uint64_t ptr) {
7023 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7024 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
7025 int64_t claimable_amount_satoshis_conv = obj->maybe_timeout_claimable_htlc.claimable_amount_satoshis;
7026 return claimable_amount_satoshis_conv;
7028 int32_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(uint64_t ptr) {
7029 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7030 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
7031 int32_t claimable_height_conv = obj->maybe_timeout_claimable_htlc.claimable_height;
7032 return claimable_height_conv;
7034 int64_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(uint64_t ptr) {
7035 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7036 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
7037 int64_t claimable_amount_satoshis_conv = obj->maybe_preimage_claimable_htlc.claimable_amount_satoshis;
7038 return claimable_amount_satoshis_conv;
7040 int32_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(uint64_t ptr) {
7041 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7042 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
7043 int32_t expiry_height_conv = obj->maybe_preimage_claimable_htlc.expiry_height;
7044 return expiry_height_conv;
7046 int64_t __attribute__((export_name("TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(uint64_t ptr) {
7047 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7048 assert(obj->tag == LDKBalance_CounterpartyRevokedOutputClaimable);
7049 int64_t claimable_amount_satoshis_conv = obj->counterparty_revoked_output_claimable.claimable_amount_satoshis;
7050 return claimable_amount_satoshis_conv;
7052 static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
7053 LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
7054 for (size_t i = 0; i < ret.datalen; i++) {
7055 ret.data[i] = Balance_clone(&orig->data[i]);
7059 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
7060 return ThirtyTwoBytes_clone(&owner->a);
7062 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_a"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_a(uint64_t owner) {
7063 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(owner);
7064 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
7065 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelMonitorZ_get_a(owner_conv).data, 32);
7069 static inline struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
7070 LDKChannelMonitor ret = owner->b;
7071 ret.is_owned = false;
7074 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_b"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_b(uint64_t owner) {
7075 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(owner);
7076 LDKChannelMonitor ret_var = C2Tuple_BlockHashChannelMonitorZ_get_b(owner_conv);
7077 uint64_t ret_ref = 0;
7078 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7079 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7083 static inline struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
7084 CHECK(owner->result_ok);
7085 return C2Tuple_BlockHashChannelMonitorZ_clone(&*owner->contents.result);
7087 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint64_t owner) {
7088 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
7089 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
7090 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner_conv);
7091 return tag_ptr(ret_conv, true);
7094 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
7095 CHECK(!owner->result_ok);
7096 return DecodeError_clone(&*owner->contents.err);
7098 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(uint64_t owner) {
7099 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
7100 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7101 *ret_copy = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner_conv);
7102 uint64_t ret_ref = tag_ptr(ret_copy, true);
7106 static inline struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
7109 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_a"))) TS_C2Tuple_PublicKeyTypeZ_get_a(uint64_t owner) {
7110 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
7111 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
7112 memcpy(ret_arr->elems, C2Tuple_PublicKeyTypeZ_get_a(owner_conv).compressed_form, 33);
7116 static inline struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
7117 return Type_clone(&owner->b);
7119 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_b"))) TS_C2Tuple_PublicKeyTypeZ_get_b(uint64_t owner) {
7120 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
7121 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
7122 *ret_ret = C2Tuple_PublicKeyTypeZ_get_b(owner_conv);
7123 return tag_ptr(ret_ret, true);
7126 static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
7127 LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
7128 for (size_t i = 0; i < ret.datalen; i++) {
7129 ret.data[i] = C2Tuple_PublicKeyTypeZ_clone(&orig->data[i]);
7133 typedef struct LDKCustomOnionMessageContents_JCalls {
7134 atomic_size_t refcnt;
7135 uint32_t instance_ptr;
7136 } LDKCustomOnionMessageContents_JCalls;
7137 static void LDKCustomOnionMessageContents_JCalls_free(void* this_arg) {
7138 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
7139 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
7143 uint64_t tlv_type_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
7144 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
7145 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 38, 0, 0, 0, 0, 0, 0);
7147 LDKCVec_u8Z write_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
7148 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
7149 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 39, 0, 0, 0, 0, 0, 0);
7150 LDKCVec_u8Z ret_ref;
7151 ret_ref.datalen = ret->arr_len;
7152 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
7153 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
7156 static void LDKCustomOnionMessageContents_JCalls_cloned(LDKCustomOnionMessageContents* new_obj) {
7157 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) new_obj->this_arg;
7158 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
7160 static inline LDKCustomOnionMessageContents LDKCustomOnionMessageContents_init (JSValue o) {
7161 LDKCustomOnionMessageContents_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageContents_JCalls), "LDKCustomOnionMessageContents_JCalls");
7162 atomic_init(&calls->refcnt, 1);
7163 calls->instance_ptr = o;
7165 LDKCustomOnionMessageContents ret = {
7166 .this_arg = (void*) calls,
7167 .tlv_type = tlv_type_LDKCustomOnionMessageContents_jcall,
7168 .write = write_LDKCustomOnionMessageContents_jcall,
7169 .cloned = LDKCustomOnionMessageContents_JCalls_cloned,
7170 .free = LDKCustomOnionMessageContents_JCalls_free,
7174 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageContents_new"))) TS_LDKCustomOnionMessageContents_new(JSValue o) {
7175 LDKCustomOnionMessageContents *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
7176 *res_ptr = LDKCustomOnionMessageContents_init(o);
7177 return tag_ptr(res_ptr, true);
7179 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_tlv_type"))) TS_CustomOnionMessageContents_tlv_type(uint64_t this_arg) {
7180 void* this_arg_ptr = untag_ptr(this_arg);
7181 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
7182 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
7183 int64_t ret_conv = (this_arg_conv->tlv_type)(this_arg_conv->this_arg);
7187 int8_tArray __attribute__((export_name("TS_CustomOnionMessageContents_write"))) TS_CustomOnionMessageContents_write(uint64_t this_arg) {
7188 void* this_arg_ptr = untag_ptr(this_arg);
7189 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
7190 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
7191 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
7192 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
7193 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
7194 CVec_u8Z_free(ret_var);
7198 uint32_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr"))) TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(uint64_t ptr) {
7199 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
7201 case LDKCOption_CustomOnionMessageContentsZ_Some: return 0;
7202 case LDKCOption_CustomOnionMessageContentsZ_None: return 1;
7206 uint64_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some"))) TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(uint64_t ptr) {
7207 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
7208 assert(obj->tag == LDKCOption_CustomOnionMessageContentsZ_Some);
7209 LDKCustomOnionMessageContents* some_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
7210 *some_ret = CustomOnionMessageContents_clone(&obj->some);
7211 return tag_ptr(some_ret, true);
7213 static inline struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
7214 CHECK(owner->result_ok);
7215 return COption_CustomOnionMessageContentsZ_clone(&*owner->contents.result);
7217 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(uint64_t owner) {
7218 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
7219 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
7220 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner_conv);
7221 uint64_t ret_ref = tag_ptr(ret_copy, true);
7225 static inline struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
7226 CHECK(!owner->result_ok);
7227 return DecodeError_clone(&*owner->contents.err);
7229 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(uint64_t owner) {
7230 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
7231 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7232 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner_conv);
7233 uint64_t ret_ref = tag_ptr(ret_copy, true);
7237 uint32_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_ty_from_ptr"))) TS_LDKCOption_NetAddressZ_ty_from_ptr(uint64_t ptr) {
7238 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)untag_ptr(ptr);
7240 case LDKCOption_NetAddressZ_Some: return 0;
7241 case LDKCOption_NetAddressZ_None: return 1;
7245 uint64_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_Some_get_some"))) TS_LDKCOption_NetAddressZ_Some_get_some(uint64_t ptr) {
7246 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)untag_ptr(ptr);
7247 assert(obj->tag == LDKCOption_NetAddressZ_Some);
7248 uint64_t some_ref = tag_ptr(&obj->some, false);
7251 static inline struct LDKPublicKey C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner){
7254 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_a"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(uint64_t owner) {
7255 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* owner_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(owner);
7256 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
7257 memcpy(ret_arr->elems, C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(owner_conv).compressed_form, 33);
7261 static inline struct LDKCOption_NetAddressZ C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner){
7262 return COption_NetAddressZ_clone(&owner->b);
7264 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_b"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(uint64_t owner) {
7265 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* owner_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(owner);
7266 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
7267 *ret_copy = C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(owner_conv);
7268 uint64_t ret_ref = tag_ptr(ret_copy, true);
7272 static inline LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_clone(const LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ *orig) {
7273 LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ clone bytes"), .datalen = orig->datalen };
7274 for (size_t i = 0; i < ret.datalen; i++) {
7275 ret.data[i] = C2Tuple_PublicKeyCOption_NetAddressZZ_clone(&orig->data[i]);
7279 static inline struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
7280 CHECK(owner->result_ok);
7281 return CVec_u8Z_clone(&*owner->contents.result);
7283 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint64_t owner) {
7284 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
7285 LDKCVec_u8Z ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner_conv);
7286 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
7287 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
7288 CVec_u8Z_free(ret_var);
7292 static inline struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
7293 LDKPeerHandleError ret = *owner->contents.err;
7294 ret.is_owned = false;
7297 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(uint64_t owner) {
7298 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
7299 LDKPeerHandleError ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner_conv);
7300 uint64_t ret_ref = 0;
7301 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7302 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7306 static inline void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
7307 CHECK(owner->result_ok);
7308 return *owner->contents.result;
7310 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_ok"))) TS_CResult_NonePeerHandleErrorZ_get_ok(uint64_t owner) {
7311 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
7312 CResult_NonePeerHandleErrorZ_get_ok(owner_conv);
7315 static inline struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
7316 LDKPeerHandleError ret = *owner->contents.err;
7317 ret.is_owned = false;
7320 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_err"))) TS_CResult_NonePeerHandleErrorZ_get_err(uint64_t owner) {
7321 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
7322 LDKPeerHandleError ret_var = CResult_NonePeerHandleErrorZ_get_err(owner_conv);
7323 uint64_t ret_ref = 0;
7324 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7325 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7329 static inline bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
7330 CHECK(owner->result_ok);
7331 return *owner->contents.result;
7333 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_ok"))) TS_CResult_boolPeerHandleErrorZ_get_ok(uint64_t owner) {
7334 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
7335 jboolean ret_conv = CResult_boolPeerHandleErrorZ_get_ok(owner_conv);
7339 static inline struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
7340 LDKPeerHandleError ret = *owner->contents.err;
7341 ret.is_owned = false;
7344 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_err"))) TS_CResult_boolPeerHandleErrorZ_get_err(uint64_t owner) {
7345 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
7346 LDKPeerHandleError ret_var = CResult_boolPeerHandleErrorZ_get_err(owner_conv);
7347 uint64_t ret_ref = 0;
7348 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7349 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7353 uint32_t __attribute__((export_name("TS_LDKSendError_ty_from_ptr"))) TS_LDKSendError_ty_from_ptr(uint64_t ptr) {
7354 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
7356 case LDKSendError_Secp256k1: return 0;
7357 case LDKSendError_TooBigPacket: return 1;
7358 case LDKSendError_TooFewBlindedHops: return 2;
7359 case LDKSendError_InvalidFirstHop: return 3;
7360 case LDKSendError_InvalidMessage: return 4;
7361 case LDKSendError_BufferFull: return 5;
7362 case LDKSendError_GetNodeIdFailed: return 6;
7363 case LDKSendError_BlindedPathAdvanceFailed: return 7;
7367 uint32_t __attribute__((export_name("TS_LDKSendError_Secp256k1_get_secp256k1"))) TS_LDKSendError_Secp256k1_get_secp256k1(uint64_t ptr) {
7368 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
7369 assert(obj->tag == LDKSendError_Secp256k1);
7370 uint32_t secp256k1_conv = LDKSecp256k1Error_to_js(obj->secp256k1);
7371 return secp256k1_conv;
7373 static inline void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
7374 CHECK(owner->result_ok);
7375 return *owner->contents.result;
7377 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_ok"))) TS_CResult_NoneSendErrorZ_get_ok(uint64_t owner) {
7378 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
7379 CResult_NoneSendErrorZ_get_ok(owner_conv);
7382 static inline struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
7383 CHECK(!owner->result_ok);
7384 return SendError_clone(&*owner->contents.err);
7386 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_err"))) TS_CResult_NoneSendErrorZ_get_err(uint64_t owner) {
7387 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
7388 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
7389 *ret_copy = CResult_NoneSendErrorZ_get_err(owner_conv);
7390 uint64_t ret_ref = tag_ptr(ret_copy, true);
7394 static inline struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
7395 LDKBlindedPath ret = *owner->contents.result;
7396 ret.is_owned = false;
7399 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_ok"))) TS_CResult_BlindedPathNoneZ_get_ok(uint64_t owner) {
7400 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
7401 LDKBlindedPath ret_var = CResult_BlindedPathNoneZ_get_ok(owner_conv);
7402 uint64_t ret_ref = 0;
7403 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7404 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7408 static inline void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
7409 CHECK(!owner->result_ok);
7410 return *owner->contents.err;
7412 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_err"))) TS_CResult_BlindedPathNoneZ_get_err(uint64_t owner) {
7413 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
7414 CResult_BlindedPathNoneZ_get_err(owner_conv);
7417 static inline struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
7418 LDKBlindedPath ret = *owner->contents.result;
7419 ret.is_owned = false;
7422 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_ok"))) TS_CResult_BlindedPathDecodeErrorZ_get_ok(uint64_t owner) {
7423 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
7424 LDKBlindedPath ret_var = CResult_BlindedPathDecodeErrorZ_get_ok(owner_conv);
7425 uint64_t ret_ref = 0;
7426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7431 static inline struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
7432 CHECK(!owner->result_ok);
7433 return DecodeError_clone(&*owner->contents.err);
7435 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_err"))) TS_CResult_BlindedPathDecodeErrorZ_get_err(uint64_t owner) {
7436 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
7437 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7438 *ret_copy = CResult_BlindedPathDecodeErrorZ_get_err(owner_conv);
7439 uint64_t ret_ref = tag_ptr(ret_copy, true);
7443 static inline struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
7444 LDKBlindedHop ret = *owner->contents.result;
7445 ret.is_owned = false;
7448 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopDecodeErrorZ_get_ok(uint64_t owner) {
7449 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
7450 LDKBlindedHop ret_var = CResult_BlindedHopDecodeErrorZ_get_ok(owner_conv);
7451 uint64_t ret_ref = 0;
7452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7453 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7457 static inline struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
7458 CHECK(!owner->result_ok);
7459 return DecodeError_clone(&*owner->contents.err);
7461 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_err"))) TS_CResult_BlindedHopDecodeErrorZ_get_err(uint64_t owner) {
7462 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
7463 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7464 *ret_copy = CResult_BlindedHopDecodeErrorZ_get_err(owner_conv);
7465 uint64_t ret_ref = tag_ptr(ret_copy, true);
7469 uint32_t __attribute__((export_name("TS_LDKGraphSyncError_ty_from_ptr"))) TS_LDKGraphSyncError_ty_from_ptr(uint64_t ptr) {
7470 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7472 case LDKGraphSyncError_DecodeError: return 0;
7473 case LDKGraphSyncError_LightningError: return 1;
7477 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_DecodeError_get_decode_error"))) TS_LDKGraphSyncError_DecodeError_get_decode_error(uint64_t ptr) {
7478 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7479 assert(obj->tag == LDKGraphSyncError_DecodeError);
7480 uint64_t decode_error_ref = tag_ptr(&obj->decode_error, false);
7481 return decode_error_ref;
7483 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_LightningError_get_lightning_error"))) TS_LDKGraphSyncError_LightningError_get_lightning_error(uint64_t ptr) {
7484 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7485 assert(obj->tag == LDKGraphSyncError_LightningError);
7486 LDKLightningError lightning_error_var = obj->lightning_error;
7487 uint64_t lightning_error_ref = 0;
7488 CHECK_INNER_FIELD_ACCESS_OR_NULL(lightning_error_var);
7489 lightning_error_ref = tag_ptr(lightning_error_var.inner, false);
7490 return lightning_error_ref;
7492 static inline uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
7493 CHECK(owner->result_ok);
7494 return *owner->contents.result;
7496 int32_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_ok"))) TS_CResult_u32GraphSyncErrorZ_get_ok(uint64_t owner) {
7497 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
7498 int32_t ret_conv = CResult_u32GraphSyncErrorZ_get_ok(owner_conv);
7502 static inline struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
7503 CHECK(!owner->result_ok);
7504 return GraphSyncError_clone(&*owner->contents.err);
7506 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_err"))) TS_CResult_u32GraphSyncErrorZ_get_err(uint64_t owner) {
7507 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
7508 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
7509 *ret_copy = CResult_u32GraphSyncErrorZ_get_err(owner_conv);
7510 uint64_t ret_ref = tag_ptr(ret_copy, true);
7514 static inline void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
7515 CHECK(owner->result_ok);
7516 return *owner->contents.result;
7518 void __attribute__((export_name("TS_CResult_NoneErrorZ_get_ok"))) TS_CResult_NoneErrorZ_get_ok(uint64_t owner) {
7519 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)untag_ptr(owner);
7520 CResult_NoneErrorZ_get_ok(owner_conv);
7523 static inline enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
7524 CHECK(!owner->result_ok);
7525 return *owner->contents.err;
7527 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_get_err"))) TS_CResult_NoneErrorZ_get_err(uint64_t owner) {
7528 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)untag_ptr(owner);
7529 uint32_t ret_conv = LDKIOError_to_js(CResult_NoneErrorZ_get_err(owner_conv));
7533 static inline struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7534 CHECK(owner->result_ok);
7535 return NetAddress_clone(&*owner->contents.result);
7537 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_ok"))) TS_CResult_NetAddressDecodeErrorZ_get_ok(uint64_t owner) {
7538 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(owner);
7539 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
7540 *ret_copy = CResult_NetAddressDecodeErrorZ_get_ok(owner_conv);
7541 uint64_t ret_ref = tag_ptr(ret_copy, true);
7545 static inline struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7546 CHECK(!owner->result_ok);
7547 return DecodeError_clone(&*owner->contents.err);
7549 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_err"))) TS_CResult_NetAddressDecodeErrorZ_get_err(uint64_t owner) {
7550 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(owner);
7551 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7552 *ret_copy = CResult_NetAddressDecodeErrorZ_get_err(owner_conv);
7553 uint64_t ret_ref = tag_ptr(ret_copy, true);
7557 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
7558 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
7559 for (size_t i = 0; i < ret.datalen; i++) {
7560 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
7564 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
7565 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
7566 for (size_t i = 0; i < ret.datalen; i++) {
7567 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
7571 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
7572 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
7573 for (size_t i = 0; i < ret.datalen; i++) {
7574 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
7578 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
7579 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
7580 for (size_t i = 0; i < ret.datalen; i++) {
7581 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
7585 static inline struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7586 LDKAcceptChannel ret = *owner->contents.result;
7587 ret.is_owned = false;
7590 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_get_ok(uint64_t owner) {
7591 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7592 LDKAcceptChannel ret_var = CResult_AcceptChannelDecodeErrorZ_get_ok(owner_conv);
7593 uint64_t ret_ref = 0;
7594 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7595 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7599 static inline struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7600 CHECK(!owner->result_ok);
7601 return DecodeError_clone(&*owner->contents.err);
7603 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_err"))) TS_CResult_AcceptChannelDecodeErrorZ_get_err(uint64_t owner) {
7604 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7605 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7606 *ret_copy = CResult_AcceptChannelDecodeErrorZ_get_err(owner_conv);
7607 uint64_t ret_ref = tag_ptr(ret_copy, true);
7611 static inline struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7612 LDKAnnouncementSignatures ret = *owner->contents.result;
7613 ret.is_owned = false;
7616 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint64_t owner) {
7617 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7618 LDKAnnouncementSignatures ret_var = CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner_conv);
7619 uint64_t ret_ref = 0;
7620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7625 static inline struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7626 CHECK(!owner->result_ok);
7627 return DecodeError_clone(&*owner->contents.err);
7629 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(uint64_t owner) {
7630 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7631 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7632 *ret_copy = CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner_conv);
7633 uint64_t ret_ref = tag_ptr(ret_copy, true);
7637 static inline struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7638 LDKChannelReestablish ret = *owner->contents.result;
7639 ret.is_owned = false;
7642 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(uint64_t owner) {
7643 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7644 LDKChannelReestablish ret_var = CResult_ChannelReestablishDecodeErrorZ_get_ok(owner_conv);
7645 uint64_t ret_ref = 0;
7646 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7647 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7651 static inline struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7652 CHECK(!owner->result_ok);
7653 return DecodeError_clone(&*owner->contents.err);
7655 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_err(uint64_t owner) {
7656 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7657 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7658 *ret_copy = CResult_ChannelReestablishDecodeErrorZ_get_err(owner_conv);
7659 uint64_t ret_ref = tag_ptr(ret_copy, true);
7663 static inline struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7664 LDKClosingSigned ret = *owner->contents.result;
7665 ret.is_owned = false;
7668 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7669 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7670 LDKClosingSigned ret_var = CResult_ClosingSignedDecodeErrorZ_get_ok(owner_conv);
7671 uint64_t ret_ref = 0;
7672 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7673 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7677 static inline struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7678 CHECK(!owner->result_ok);
7679 return DecodeError_clone(&*owner->contents.err);
7681 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedDecodeErrorZ_get_err(uint64_t owner) {
7682 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7683 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7684 *ret_copy = CResult_ClosingSignedDecodeErrorZ_get_err(owner_conv);
7685 uint64_t ret_ref = tag_ptr(ret_copy, true);
7689 static inline struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7690 LDKClosingSignedFeeRange ret = *owner->contents.result;
7691 ret.is_owned = false;
7694 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint64_t owner) {
7695 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7696 LDKClosingSignedFeeRange ret_var = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner_conv);
7697 uint64_t ret_ref = 0;
7698 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7699 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7703 static inline struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7704 CHECK(!owner->result_ok);
7705 return DecodeError_clone(&*owner->contents.err);
7707 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(uint64_t owner) {
7708 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7709 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7710 *ret_copy = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner_conv);
7711 uint64_t ret_ref = tag_ptr(ret_copy, true);
7715 static inline struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7716 LDKCommitmentSigned ret = *owner->contents.result;
7717 ret.is_owned = false;
7720 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(uint64_t owner) {
7721 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7722 LDKCommitmentSigned ret_var = CResult_CommitmentSignedDecodeErrorZ_get_ok(owner_conv);
7723 uint64_t ret_ref = 0;
7724 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7725 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7729 static inline struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7730 CHECK(!owner->result_ok);
7731 return DecodeError_clone(&*owner->contents.err);
7733 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_err(uint64_t owner) {
7734 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7735 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7736 *ret_copy = CResult_CommitmentSignedDecodeErrorZ_get_err(owner_conv);
7737 uint64_t ret_ref = tag_ptr(ret_copy, true);
7741 static inline struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7742 LDKFundingCreated ret = *owner->contents.result;
7743 ret.is_owned = false;
7746 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_get_ok(uint64_t owner) {
7747 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7748 LDKFundingCreated ret_var = CResult_FundingCreatedDecodeErrorZ_get_ok(owner_conv);
7749 uint64_t ret_ref = 0;
7750 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7751 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7755 static inline struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7756 CHECK(!owner->result_ok);
7757 return DecodeError_clone(&*owner->contents.err);
7759 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_err"))) TS_CResult_FundingCreatedDecodeErrorZ_get_err(uint64_t owner) {
7760 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7761 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7762 *ret_copy = CResult_FundingCreatedDecodeErrorZ_get_err(owner_conv);
7763 uint64_t ret_ref = tag_ptr(ret_copy, true);
7767 static inline struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7768 LDKFundingSigned ret = *owner->contents.result;
7769 ret.is_owned = false;
7772 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_ok"))) TS_CResult_FundingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7773 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7774 LDKFundingSigned ret_var = CResult_FundingSignedDecodeErrorZ_get_ok(owner_conv);
7775 uint64_t ret_ref = 0;
7776 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7777 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7781 static inline struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7782 CHECK(!owner->result_ok);
7783 return DecodeError_clone(&*owner->contents.err);
7785 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_err"))) TS_CResult_FundingSignedDecodeErrorZ_get_err(uint64_t owner) {
7786 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7787 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7788 *ret_copy = CResult_FundingSignedDecodeErrorZ_get_err(owner_conv);
7789 uint64_t ret_ref = tag_ptr(ret_copy, true);
7793 static inline struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7794 LDKChannelReady ret = *owner->contents.result;
7795 ret.is_owned = false;
7798 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_get_ok(uint64_t owner) {
7799 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7800 LDKChannelReady ret_var = CResult_ChannelReadyDecodeErrorZ_get_ok(owner_conv);
7801 uint64_t ret_ref = 0;
7802 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7803 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7807 static inline struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7808 CHECK(!owner->result_ok);
7809 return DecodeError_clone(&*owner->contents.err);
7811 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_err"))) TS_CResult_ChannelReadyDecodeErrorZ_get_err(uint64_t owner) {
7812 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7813 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7814 *ret_copy = CResult_ChannelReadyDecodeErrorZ_get_err(owner_conv);
7815 uint64_t ret_ref = tag_ptr(ret_copy, true);
7819 static inline struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7820 LDKInit ret = *owner->contents.result;
7821 ret.is_owned = false;
7824 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_ok"))) TS_CResult_InitDecodeErrorZ_get_ok(uint64_t owner) {
7825 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7826 LDKInit ret_var = CResult_InitDecodeErrorZ_get_ok(owner_conv);
7827 uint64_t ret_ref = 0;
7828 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7829 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7833 static inline struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7834 CHECK(!owner->result_ok);
7835 return DecodeError_clone(&*owner->contents.err);
7837 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_err"))) TS_CResult_InitDecodeErrorZ_get_err(uint64_t owner) {
7838 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7839 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7840 *ret_copy = CResult_InitDecodeErrorZ_get_err(owner_conv);
7841 uint64_t ret_ref = tag_ptr(ret_copy, true);
7845 static inline struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7846 LDKOpenChannel ret = *owner->contents.result;
7847 ret.is_owned = false;
7850 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_ok"))) TS_CResult_OpenChannelDecodeErrorZ_get_ok(uint64_t owner) {
7851 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7852 LDKOpenChannel ret_var = CResult_OpenChannelDecodeErrorZ_get_ok(owner_conv);
7853 uint64_t ret_ref = 0;
7854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7855 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7859 static inline struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7860 CHECK(!owner->result_ok);
7861 return DecodeError_clone(&*owner->contents.err);
7863 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_err"))) TS_CResult_OpenChannelDecodeErrorZ_get_err(uint64_t owner) {
7864 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7865 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7866 *ret_copy = CResult_OpenChannelDecodeErrorZ_get_err(owner_conv);
7867 uint64_t ret_ref = tag_ptr(ret_copy, true);
7871 static inline struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7872 LDKRevokeAndACK ret = *owner->contents.result;
7873 ret.is_owned = false;
7876 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(uint64_t owner) {
7877 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7878 LDKRevokeAndACK ret_var = CResult_RevokeAndACKDecodeErrorZ_get_ok(owner_conv);
7879 uint64_t ret_ref = 0;
7880 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7881 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7885 static inline struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7886 CHECK(!owner->result_ok);
7887 return DecodeError_clone(&*owner->contents.err);
7889 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_err(uint64_t owner) {
7890 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7891 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7892 *ret_copy = CResult_RevokeAndACKDecodeErrorZ_get_err(owner_conv);
7893 uint64_t ret_ref = tag_ptr(ret_copy, true);
7897 static inline struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7898 LDKShutdown ret = *owner->contents.result;
7899 ret.is_owned = false;
7902 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_ok"))) TS_CResult_ShutdownDecodeErrorZ_get_ok(uint64_t owner) {
7903 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7904 LDKShutdown ret_var = CResult_ShutdownDecodeErrorZ_get_ok(owner_conv);
7905 uint64_t ret_ref = 0;
7906 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7907 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7911 static inline struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7912 CHECK(!owner->result_ok);
7913 return DecodeError_clone(&*owner->contents.err);
7915 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_err"))) TS_CResult_ShutdownDecodeErrorZ_get_err(uint64_t owner) {
7916 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7917 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7918 *ret_copy = CResult_ShutdownDecodeErrorZ_get_err(owner_conv);
7919 uint64_t ret_ref = tag_ptr(ret_copy, true);
7923 static inline struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7924 LDKUpdateFailHTLC ret = *owner->contents.result;
7925 ret.is_owned = false;
7928 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7929 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
7930 LDKUpdateFailHTLC ret_var = CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner_conv);
7931 uint64_t ret_ref = 0;
7932 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7933 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7937 static inline struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7938 CHECK(!owner->result_ok);
7939 return DecodeError_clone(&*owner->contents.err);
7941 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(uint64_t owner) {
7942 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
7943 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7944 *ret_copy = CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner_conv);
7945 uint64_t ret_ref = tag_ptr(ret_copy, true);
7949 static inline struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7950 LDKUpdateFailMalformedHTLC ret = *owner->contents.result;
7951 ret.is_owned = false;
7954 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7955 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
7956 LDKUpdateFailMalformedHTLC ret_var = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner_conv);
7957 uint64_t ret_ref = 0;
7958 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7959 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7963 static inline struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7964 CHECK(!owner->result_ok);
7965 return DecodeError_clone(&*owner->contents.err);
7967 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(uint64_t owner) {
7968 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
7969 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7970 *ret_copy = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner_conv);
7971 uint64_t ret_ref = tag_ptr(ret_copy, true);
7975 static inline struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7976 LDKUpdateFee ret = *owner->contents.result;
7977 ret.is_owned = false;
7980 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_get_ok(uint64_t owner) {
7981 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
7982 LDKUpdateFee ret_var = CResult_UpdateFeeDecodeErrorZ_get_ok(owner_conv);
7983 uint64_t ret_ref = 0;
7984 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7985 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7989 static inline struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7990 CHECK(!owner->result_ok);
7991 return DecodeError_clone(&*owner->contents.err);
7993 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_err"))) TS_CResult_UpdateFeeDecodeErrorZ_get_err(uint64_t owner) {
7994 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
7995 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7996 *ret_copy = CResult_UpdateFeeDecodeErrorZ_get_err(owner_conv);
7997 uint64_t ret_ref = tag_ptr(ret_copy, true);
8001 static inline struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
8002 LDKUpdateFulfillHTLC ret = *owner->contents.result;
8003 ret.is_owned = false;
8006 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8007 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
8008 LDKUpdateFulfillHTLC ret_var = CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner_conv);
8009 uint64_t ret_ref = 0;
8010 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8011 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8015 static inline struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
8016 CHECK(!owner->result_ok);
8017 return DecodeError_clone(&*owner->contents.err);
8019 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(uint64_t owner) {
8020 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
8021 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8022 *ret_copy = CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner_conv);
8023 uint64_t ret_ref = tag_ptr(ret_copy, true);
8027 static inline struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
8028 LDKUpdateAddHTLC ret = *owner->contents.result;
8029 ret.is_owned = false;
8032 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8033 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
8034 LDKUpdateAddHTLC ret_var = CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner_conv);
8035 uint64_t ret_ref = 0;
8036 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8037 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8041 static inline struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
8042 CHECK(!owner->result_ok);
8043 return DecodeError_clone(&*owner->contents.err);
8045 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(uint64_t owner) {
8046 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
8047 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8048 *ret_copy = CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner_conv);
8049 uint64_t ret_ref = tag_ptr(ret_copy, true);
8053 static inline struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
8054 LDKOnionMessage ret = *owner->contents.result;
8055 ret.is_owned = false;
8058 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_ok"))) TS_CResult_OnionMessageDecodeErrorZ_get_ok(uint64_t owner) {
8059 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
8060 LDKOnionMessage ret_var = CResult_OnionMessageDecodeErrorZ_get_ok(owner_conv);
8061 uint64_t ret_ref = 0;
8062 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8063 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8067 static inline struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
8068 CHECK(!owner->result_ok);
8069 return DecodeError_clone(&*owner->contents.err);
8071 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_err"))) TS_CResult_OnionMessageDecodeErrorZ_get_err(uint64_t owner) {
8072 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
8073 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8074 *ret_copy = CResult_OnionMessageDecodeErrorZ_get_err(owner_conv);
8075 uint64_t ret_ref = tag_ptr(ret_copy, true);
8079 static inline struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
8080 LDKPing ret = *owner->contents.result;
8081 ret.is_owned = false;
8084 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_ok"))) TS_CResult_PingDecodeErrorZ_get_ok(uint64_t owner) {
8085 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
8086 LDKPing ret_var = CResult_PingDecodeErrorZ_get_ok(owner_conv);
8087 uint64_t ret_ref = 0;
8088 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8089 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8093 static inline struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
8094 CHECK(!owner->result_ok);
8095 return DecodeError_clone(&*owner->contents.err);
8097 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_err"))) TS_CResult_PingDecodeErrorZ_get_err(uint64_t owner) {
8098 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
8099 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8100 *ret_copy = CResult_PingDecodeErrorZ_get_err(owner_conv);
8101 uint64_t ret_ref = tag_ptr(ret_copy, true);
8105 static inline struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
8106 LDKPong ret = *owner->contents.result;
8107 ret.is_owned = false;
8110 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_ok"))) TS_CResult_PongDecodeErrorZ_get_ok(uint64_t owner) {
8111 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
8112 LDKPong ret_var = CResult_PongDecodeErrorZ_get_ok(owner_conv);
8113 uint64_t ret_ref = 0;
8114 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8115 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8119 static inline struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
8120 CHECK(!owner->result_ok);
8121 return DecodeError_clone(&*owner->contents.err);
8123 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_err"))) TS_CResult_PongDecodeErrorZ_get_err(uint64_t owner) {
8124 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
8125 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8126 *ret_copy = CResult_PongDecodeErrorZ_get_err(owner_conv);
8127 uint64_t ret_ref = tag_ptr(ret_copy, true);
8131 static inline struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8132 LDKUnsignedChannelAnnouncement ret = *owner->contents.result;
8133 ret.is_owned = false;
8136 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8137 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8138 LDKUnsignedChannelAnnouncement ret_var = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
8139 uint64_t ret_ref = 0;
8140 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8141 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8145 static inline struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8146 CHECK(!owner->result_ok);
8147 return DecodeError_clone(&*owner->contents.err);
8149 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8150 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8151 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8152 *ret_copy = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
8153 uint64_t ret_ref = tag_ptr(ret_copy, true);
8157 static inline struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8158 LDKChannelAnnouncement ret = *owner->contents.result;
8159 ret.is_owned = false;
8162 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8163 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8164 LDKChannelAnnouncement ret_var = CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
8165 uint64_t ret_ref = 0;
8166 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8167 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8171 static inline struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8172 CHECK(!owner->result_ok);
8173 return DecodeError_clone(&*owner->contents.err);
8175 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8176 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8177 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8178 *ret_copy = CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
8179 uint64_t ret_ref = tag_ptr(ret_copy, true);
8183 static inline struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8184 LDKUnsignedChannelUpdate ret = *owner->contents.result;
8185 ret.is_owned = false;
8188 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
8189 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8190 LDKUnsignedChannelUpdate ret_var = CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner_conv);
8191 uint64_t ret_ref = 0;
8192 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8193 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8197 static inline struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8198 CHECK(!owner->result_ok);
8199 return DecodeError_clone(&*owner->contents.err);
8201 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
8202 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8203 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8204 *ret_copy = CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner_conv);
8205 uint64_t ret_ref = tag_ptr(ret_copy, true);
8209 static inline struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8210 LDKChannelUpdate ret = *owner->contents.result;
8211 ret.is_owned = false;
8214 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
8215 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8216 LDKChannelUpdate ret_var = CResult_ChannelUpdateDecodeErrorZ_get_ok(owner_conv);
8217 uint64_t ret_ref = 0;
8218 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8219 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8223 static inline struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8224 CHECK(!owner->result_ok);
8225 return DecodeError_clone(&*owner->contents.err);
8227 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
8228 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8229 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8230 *ret_copy = CResult_ChannelUpdateDecodeErrorZ_get_err(owner_conv);
8231 uint64_t ret_ref = tag_ptr(ret_copy, true);
8235 static inline struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
8236 LDKErrorMessage ret = *owner->contents.result;
8237 ret.is_owned = false;
8240 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_get_ok(uint64_t owner) {
8241 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
8242 LDKErrorMessage ret_var = CResult_ErrorMessageDecodeErrorZ_get_ok(owner_conv);
8243 uint64_t ret_ref = 0;
8244 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8245 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8249 static inline struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
8250 CHECK(!owner->result_ok);
8251 return DecodeError_clone(&*owner->contents.err);
8253 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_err"))) TS_CResult_ErrorMessageDecodeErrorZ_get_err(uint64_t owner) {
8254 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
8255 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8256 *ret_copy = CResult_ErrorMessageDecodeErrorZ_get_err(owner_conv);
8257 uint64_t ret_ref = tag_ptr(ret_copy, true);
8261 static inline struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
8262 LDKWarningMessage ret = *owner->contents.result;
8263 ret.is_owned = false;
8266 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_ok"))) TS_CResult_WarningMessageDecodeErrorZ_get_ok(uint64_t owner) {
8267 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
8268 LDKWarningMessage ret_var = CResult_WarningMessageDecodeErrorZ_get_ok(owner_conv);
8269 uint64_t ret_ref = 0;
8270 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8271 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8275 static inline struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
8276 CHECK(!owner->result_ok);
8277 return DecodeError_clone(&*owner->contents.err);
8279 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_err"))) TS_CResult_WarningMessageDecodeErrorZ_get_err(uint64_t owner) {
8280 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
8281 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8282 *ret_copy = CResult_WarningMessageDecodeErrorZ_get_err(owner_conv);
8283 uint64_t ret_ref = tag_ptr(ret_copy, true);
8287 static inline struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8288 LDKUnsignedNodeAnnouncement ret = *owner->contents.result;
8289 ret.is_owned = false;
8292 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8293 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8294 LDKUnsignedNodeAnnouncement ret_var = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8295 uint64_t ret_ref = 0;
8296 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8297 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8301 static inline struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8302 CHECK(!owner->result_ok);
8303 return DecodeError_clone(&*owner->contents.err);
8305 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8306 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8307 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8308 *ret_copy = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8309 uint64_t ret_ref = tag_ptr(ret_copy, true);
8313 static inline struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8314 LDKNodeAnnouncement ret = *owner->contents.result;
8315 ret.is_owned = false;
8318 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8319 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8320 LDKNodeAnnouncement ret_var = CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8321 uint64_t ret_ref = 0;
8322 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8323 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8327 static inline struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8328 CHECK(!owner->result_ok);
8329 return DecodeError_clone(&*owner->contents.err);
8331 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8332 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8333 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8334 *ret_copy = CResult_NodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8335 uint64_t ret_ref = tag_ptr(ret_copy, true);
8339 static inline struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8340 LDKQueryShortChannelIds ret = *owner->contents.result;
8341 ret.is_owned = false;
8344 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint64_t owner) {
8345 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
8346 LDKQueryShortChannelIds ret_var = CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner_conv);
8347 uint64_t ret_ref = 0;
8348 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8349 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8353 static inline struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8354 CHECK(!owner->result_ok);
8355 return DecodeError_clone(&*owner->contents.err);
8357 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(uint64_t owner) {
8358 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
8359 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8360 *ret_copy = CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner_conv);
8361 uint64_t ret_ref = tag_ptr(ret_copy, true);
8365 static inline struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8366 LDKReplyShortChannelIdsEnd ret = *owner->contents.result;
8367 ret.is_owned = false;
8370 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint64_t owner) {
8371 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
8372 LDKReplyShortChannelIdsEnd ret_var = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner_conv);
8373 uint64_t ret_ref = 0;
8374 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8375 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8379 static inline struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8380 CHECK(!owner->result_ok);
8381 return DecodeError_clone(&*owner->contents.err);
8383 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(uint64_t owner) {
8384 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
8385 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8386 *ret_copy = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner_conv);
8387 uint64_t ret_ref = tag_ptr(ret_copy, true);
8391 static inline struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8392 LDKQueryChannelRange ret = *owner->contents.result;
8393 ret.is_owned = false;
8396 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
8397 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
8398 LDKQueryChannelRange ret_var = CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner_conv);
8399 uint64_t ret_ref = 0;
8400 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8401 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8405 static inline struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8406 CHECK(!owner->result_ok);
8407 return DecodeError_clone(&*owner->contents.err);
8409 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
8410 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
8411 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8412 *ret_copy = CResult_QueryChannelRangeDecodeErrorZ_get_err(owner_conv);
8413 uint64_t ret_ref = tag_ptr(ret_copy, true);
8417 static inline struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8418 LDKReplyChannelRange ret = *owner->contents.result;
8419 ret.is_owned = false;
8422 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
8423 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
8424 LDKReplyChannelRange ret_var = CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner_conv);
8425 uint64_t ret_ref = 0;
8426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8431 static inline struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8432 CHECK(!owner->result_ok);
8433 return DecodeError_clone(&*owner->contents.err);
8435 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
8436 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
8437 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8438 *ret_copy = CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner_conv);
8439 uint64_t ret_ref = tag_ptr(ret_copy, true);
8443 static inline struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8444 LDKGossipTimestampFilter ret = *owner->contents.result;
8445 ret.is_owned = false;
8448 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint64_t owner) {
8449 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
8450 LDKGossipTimestampFilter ret_var = CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner_conv);
8451 uint64_t ret_ref = 0;
8452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8453 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8457 static inline struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8458 CHECK(!owner->result_ok);
8459 return DecodeError_clone(&*owner->contents.err);
8461 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(uint64_t owner) {
8462 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
8463 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8464 *ret_copy = CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner_conv);
8465 uint64_t ret_ref = tag_ptr(ret_copy, true);
8469 typedef struct LDKFilter_JCalls {
8470 atomic_size_t refcnt;
8471 uint32_t instance_ptr;
8473 static void LDKFilter_JCalls_free(void* this_arg) {
8474 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8475 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8479 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
8480 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8481 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
8482 memcpy(txid_arr->elems, *txid, 32);
8483 LDKu8slice script_pubkey_var = script_pubkey;
8484 int8_tArray script_pubkey_arr = init_int8_tArray(script_pubkey_var.datalen, __LINE__);
8485 memcpy(script_pubkey_arr->elems, script_pubkey_var.data, script_pubkey_var.datalen);
8486 js_invoke_function_uuuuuu(j_calls->instance_ptr, 40, (uint32_t)txid_arr, (uint32_t)script_pubkey_arr, 0, 0, 0, 0);
8488 void register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
8489 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8490 LDKWatchedOutput output_var = output;
8491 uint64_t output_ref = 0;
8492 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
8493 output_ref = tag_ptr(output_var.inner, output_var.is_owned);
8494 js_invoke_function_buuuuu(j_calls->instance_ptr, 41, output_ref, 0, 0, 0, 0, 0);
8496 static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
8497 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg;
8498 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8500 static inline LDKFilter LDKFilter_init (JSValue o) {
8501 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
8502 atomic_init(&calls->refcnt, 1);
8503 calls->instance_ptr = o;
8506 .this_arg = (void*) calls,
8507 .register_tx = register_tx_LDKFilter_jcall,
8508 .register_output = register_output_LDKFilter_jcall,
8509 .free = LDKFilter_JCalls_free,
8513 uint64_t __attribute__((export_name("TS_LDKFilter_new"))) TS_LDKFilter_new(JSValue o) {
8514 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
8515 *res_ptr = LDKFilter_init(o);
8516 return tag_ptr(res_ptr, true);
8518 void __attribute__((export_name("TS_Filter_register_tx"))) TS_Filter_register_tx(uint64_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
8519 void* this_arg_ptr = untag_ptr(this_arg);
8520 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8521 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8522 uint8_t txid_arr[32];
8523 CHECK(txid->arr_len == 32);
8524 memcpy(txid_arr, txid->elems, 32); FREE(txid);
8525 uint8_t (*txid_ref)[32] = &txid_arr;
8526 LDKu8slice script_pubkey_ref;
8527 script_pubkey_ref.datalen = script_pubkey->arr_len;
8528 script_pubkey_ref.data = script_pubkey->elems;
8529 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
8530 FREE(script_pubkey);
8533 void __attribute__((export_name("TS_Filter_register_output"))) TS_Filter_register_output(uint64_t this_arg, uint64_t output) {
8534 void* this_arg_ptr = untag_ptr(this_arg);
8535 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8536 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8537 LDKWatchedOutput output_conv;
8538 output_conv.inner = untag_ptr(output);
8539 output_conv.is_owned = ptr_is_owned(output);
8540 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
8541 output_conv = WatchedOutput_clone(&output_conv);
8542 (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
8545 uint32_t __attribute__((export_name("TS_LDKCOption_FilterZ_ty_from_ptr"))) TS_LDKCOption_FilterZ_ty_from_ptr(uint64_t ptr) {
8546 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
8548 case LDKCOption_FilterZ_Some: return 0;
8549 case LDKCOption_FilterZ_None: return 1;
8553 uint64_t __attribute__((export_name("TS_LDKCOption_FilterZ_Some_get_some"))) TS_LDKCOption_FilterZ_Some_get_some(uint64_t ptr) {
8554 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
8555 assert(obj->tag == LDKCOption_FilterZ_Some);
8556 LDKFilter* some_ret = MALLOC(sizeof(LDKFilter), "LDKFilter");
8557 *some_ret = obj->some;
8558 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
8559 if ((*some_ret).free == LDKFilter_JCalls_free) {
8560 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8561 LDKFilter_JCalls_cloned(&(*some_ret));
8563 return tag_ptr(some_ret, true);
8565 static inline struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8566 LDKLockedChannelMonitor ret = *owner->contents.result;
8567 ret.is_owned = false;
8570 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_ok"))) TS_CResult_LockedChannelMonitorNoneZ_get_ok(uint64_t owner) {
8571 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
8572 LDKLockedChannelMonitor ret_var = CResult_LockedChannelMonitorNoneZ_get_ok(owner_conv);
8573 uint64_t ret_ref = 0;
8574 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8575 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8579 static inline void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8580 CHECK(!owner->result_ok);
8581 return *owner->contents.err;
8583 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_err"))) TS_CResult_LockedChannelMonitorNoneZ_get_err(uint64_t owner) {
8584 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
8585 CResult_LockedChannelMonitorNoneZ_get_err(owner_conv);
8588 static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
8589 LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
8590 for (size_t i = 0; i < ret.datalen; i++) {
8591 ret.data[i] = OutPoint_clone(&orig->data[i]);
8595 static inline LDKCVec_MonitorUpdateIdZ CVec_MonitorUpdateIdZ_clone(const LDKCVec_MonitorUpdateIdZ *orig) {
8596 LDKCVec_MonitorUpdateIdZ ret = { .data = MALLOC(sizeof(LDKMonitorUpdateId) * orig->datalen, "LDKCVec_MonitorUpdateIdZ clone bytes"), .datalen = orig->datalen };
8597 for (size_t i = 0; i < ret.datalen; i++) {
8598 ret.data[i] = MonitorUpdateId_clone(&orig->data[i]);
8602 static inline struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
8603 LDKOutPoint ret = owner->a;
8604 ret.is_owned = false;
8607 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(uint64_t owner) {
8608 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
8609 LDKOutPoint ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner_conv);
8610 uint64_t ret_ref = 0;
8611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8612 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8616 static inline struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
8617 return CVec_MonitorUpdateIdZ_clone(&owner->b);
8619 uint64_tArray __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(uint64_t owner) {
8620 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
8621 LDKCVec_MonitorUpdateIdZ ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner_conv);
8622 uint64_tArray ret_arr = NULL;
8623 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
8624 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
8625 for (size_t r = 0; r < ret_var.datalen; r++) {
8626 LDKMonitorUpdateId ret_conv_17_var = ret_var.data[r];
8627 uint64_t ret_conv_17_ref = 0;
8628 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_17_var);
8629 ret_conv_17_ref = tag_ptr(ret_conv_17_var.inner, ret_conv_17_var.is_owned);
8630 ret_arr_ptr[r] = ret_conv_17_ref;
8637 static inline LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_clone(const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ *orig) {
8638 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ) * orig->datalen, "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ clone bytes"), .datalen = orig->datalen };
8639 for (size_t i = 0; i < ret.datalen; i++) {
8640 ret.data[i] = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(&orig->data[i]);
8644 static inline LDKCVec_PhantomRouteHintsZ CVec_PhantomRouteHintsZ_clone(const LDKCVec_PhantomRouteHintsZ *orig) {
8645 LDKCVec_PhantomRouteHintsZ ret = { .data = MALLOC(sizeof(LDKPhantomRouteHints) * orig->datalen, "LDKCVec_PhantomRouteHintsZ clone bytes"), .datalen = orig->datalen };
8646 for (size_t i = 0; i < ret.datalen; i++) {
8647 ret.data[i] = PhantomRouteHints_clone(&orig->data[i]);
8651 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_ty_from_ptr"))) TS_LDKSignOrCreationError_ty_from_ptr(uint64_t ptr) {
8652 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
8654 case LDKSignOrCreationError_SignError: return 0;
8655 case LDKSignOrCreationError_CreationError: return 1;
8659 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_CreationError_get_creation_error"))) TS_LDKSignOrCreationError_CreationError_get_creation_error(uint64_t ptr) {
8660 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
8661 assert(obj->tag == LDKSignOrCreationError_CreationError);
8662 uint32_t creation_error_conv = LDKCreationError_to_js(obj->creation_error);
8663 return creation_error_conv;
8665 static inline struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8666 LDKInvoice ret = *owner->contents.result;
8667 ret.is_owned = false;
8670 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(uint64_t owner) {
8671 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
8672 LDKInvoice ret_var = CResult_InvoiceSignOrCreationErrorZ_get_ok(owner_conv);
8673 uint64_t ret_ref = 0;
8674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8675 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8679 static inline struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8680 CHECK(!owner->result_ok);
8681 return SignOrCreationError_clone(&*owner->contents.err);
8683 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_err(uint64_t owner) {
8684 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
8685 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
8686 *ret_copy = CResult_InvoiceSignOrCreationErrorZ_get_err(owner_conv);
8687 uint64_t ret_ref = tag_ptr(ret_copy, true);
8691 uint32_t __attribute__((export_name("TS_LDKParseError_ty_from_ptr"))) TS_LDKParseError_ty_from_ptr(uint64_t ptr) {
8692 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8694 case LDKParseError_Bech32Error: return 0;
8695 case LDKParseError_ParseAmountError: return 1;
8696 case LDKParseError_MalformedSignature: return 2;
8697 case LDKParseError_BadPrefix: return 3;
8698 case LDKParseError_UnknownCurrency: return 4;
8699 case LDKParseError_UnknownSiPrefix: return 5;
8700 case LDKParseError_MalformedHRP: return 6;
8701 case LDKParseError_TooShortDataPart: return 7;
8702 case LDKParseError_UnexpectedEndOfTaggedFields: return 8;
8703 case LDKParseError_DescriptionDecodeError: return 9;
8704 case LDKParseError_PaddingError: return 10;
8705 case LDKParseError_IntegerOverflowError: return 11;
8706 case LDKParseError_InvalidSegWitProgramLength: return 12;
8707 case LDKParseError_InvalidPubKeyHashLength: return 13;
8708 case LDKParseError_InvalidScriptHashLength: return 14;
8709 case LDKParseError_InvalidRecoveryId: return 15;
8710 case LDKParseError_InvalidSliceLength: return 16;
8711 case LDKParseError_Skip: return 17;
8715 uint64_t __attribute__((export_name("TS_LDKParseError_Bech32Error_get_bech32_error"))) TS_LDKParseError_Bech32Error_get_bech32_error(uint64_t ptr) {
8716 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8717 assert(obj->tag == LDKParseError_Bech32Error);
8718 uint64_t bech32_error_ref = tag_ptr(&obj->bech32_error, false);
8719 return bech32_error_ref;
8721 int32_t __attribute__((export_name("TS_LDKParseError_ParseAmountError_get_parse_amount_error"))) TS_LDKParseError_ParseAmountError_get_parse_amount_error(uint64_t ptr) {
8722 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8723 assert(obj->tag == LDKParseError_ParseAmountError);
8724 /*obj->parse_amount_error*/
8727 uint32_t __attribute__((export_name("TS_LDKParseError_MalformedSignature_get_malformed_signature"))) TS_LDKParseError_MalformedSignature_get_malformed_signature(uint64_t ptr) {
8728 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8729 assert(obj->tag == LDKParseError_MalformedSignature);
8730 uint32_t malformed_signature_conv = LDKSecp256k1Error_to_js(obj->malformed_signature);
8731 return malformed_signature_conv;
8733 int32_t __attribute__((export_name("TS_LDKParseError_DescriptionDecodeError_get_description_decode_error"))) TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(uint64_t ptr) {
8734 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8735 assert(obj->tag == LDKParseError_DescriptionDecodeError);
8736 /*obj->description_decode_error*/
8739 jstring __attribute__((export_name("TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length"))) TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(uint64_t ptr) {
8740 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8741 assert(obj->tag == LDKParseError_InvalidSliceLength);
8742 LDKStr invalid_slice_length_str = obj->invalid_slice_length;
8743 jstring invalid_slice_length_conv = str_ref_to_ts(invalid_slice_length_str.chars, invalid_slice_length_str.len);
8744 return invalid_slice_length_conv;
8746 static inline enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
8747 CHECK(owner->result_ok);
8748 return SiPrefix_clone(&*owner->contents.result);
8750 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_ok"))) TS_CResult_SiPrefixParseErrorZ_get_ok(uint64_t owner) {
8751 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(owner);
8752 uint32_t ret_conv = LDKSiPrefix_to_js(CResult_SiPrefixParseErrorZ_get_ok(owner_conv));
8756 static inline struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
8757 CHECK(!owner->result_ok);
8758 return ParseError_clone(&*owner->contents.err);
8760 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_err"))) TS_CResult_SiPrefixParseErrorZ_get_err(uint64_t owner) {
8761 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(owner);
8762 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
8763 *ret_copy = CResult_SiPrefixParseErrorZ_get_err(owner_conv);
8764 uint64_t ret_ref = tag_ptr(ret_copy, true);
8768 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_ty_from_ptr"))) TS_LDKParseOrSemanticError_ty_from_ptr(uint64_t ptr) {
8769 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
8771 case LDKParseOrSemanticError_ParseError: return 0;
8772 case LDKParseOrSemanticError_SemanticError: return 1;
8776 uint64_t __attribute__((export_name("TS_LDKParseOrSemanticError_ParseError_get_parse_error"))) TS_LDKParseOrSemanticError_ParseError_get_parse_error(uint64_t ptr) {
8777 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
8778 assert(obj->tag == LDKParseOrSemanticError_ParseError);
8779 uint64_t parse_error_ref = tag_ptr(&obj->parse_error, false);
8780 return parse_error_ref;
8782 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_SemanticError_get_semantic_error"))) TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(uint64_t ptr) {
8783 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
8784 assert(obj->tag == LDKParseOrSemanticError_SemanticError);
8785 uint32_t semantic_error_conv = LDKSemanticError_to_js(obj->semantic_error);
8786 return semantic_error_conv;
8788 static inline struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
8789 LDKInvoice ret = *owner->contents.result;
8790 ret.is_owned = false;
8793 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(uint64_t owner) {
8794 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
8795 LDKInvoice ret_var = CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner_conv);
8796 uint64_t ret_ref = 0;
8797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8798 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8802 static inline struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
8803 CHECK(!owner->result_ok);
8804 return ParseOrSemanticError_clone(&*owner->contents.err);
8806 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(uint64_t owner) {
8807 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
8808 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
8809 *ret_copy = CResult_InvoiceParseOrSemanticErrorZ_get_err(owner_conv);
8810 uint64_t ret_ref = tag_ptr(ret_copy, true);
8814 static inline struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
8815 LDKSignedRawInvoice ret = *owner->contents.result;
8816 ret.is_owned = false;
8819 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(uint64_t owner) {
8820 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(owner);
8821 LDKSignedRawInvoice ret_var = CResult_SignedRawInvoiceParseErrorZ_get_ok(owner_conv);
8822 uint64_t ret_ref = 0;
8823 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8824 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8828 static inline struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
8829 CHECK(!owner->result_ok);
8830 return ParseError_clone(&*owner->contents.err);
8832 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_err(uint64_t owner) {
8833 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(owner);
8834 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
8835 *ret_copy = CResult_SignedRawInvoiceParseErrorZ_get_err(owner_conv);
8836 uint64_t ret_ref = tag_ptr(ret_copy, true);
8840 static inline struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
8841 LDKRawInvoice ret = owner->a;
8842 ret.is_owned = false;
8845 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint64_t owner) {
8846 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
8847 LDKRawInvoice ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner_conv);
8848 uint64_t ret_ref = 0;
8849 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8850 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8854 static inline struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
8855 return ThirtyTwoBytes_clone(&owner->b);
8857 int8_tArray __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint64_t owner) {
8858 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
8859 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
8860 memcpy(ret_arr->elems, C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner_conv).data, 32);
8864 static inline struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
8865 LDKInvoiceSignature ret = owner->c;
8866 ret.is_owned = false;
8869 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint64_t owner) {
8870 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
8871 LDKInvoiceSignature ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner_conv);
8872 uint64_t ret_ref = 0;
8873 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8874 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8878 static inline struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
8879 LDKPayeePubKey ret = *owner->contents.result;
8880 ret.is_owned = false;
8883 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_ok"))) TS_CResult_PayeePubKeyErrorZ_get_ok(uint64_t owner) {
8884 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(owner);
8885 LDKPayeePubKey ret_var = CResult_PayeePubKeyErrorZ_get_ok(owner_conv);
8886 uint64_t ret_ref = 0;
8887 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8888 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8892 static inline enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
8893 CHECK(!owner->result_ok);
8894 return *owner->contents.err;
8896 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_err"))) TS_CResult_PayeePubKeyErrorZ_get_err(uint64_t owner) {
8897 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(owner);
8898 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PayeePubKeyErrorZ_get_err(owner_conv));
8902 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
8903 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
8904 for (size_t i = 0; i < ret.datalen; i++) {
8905 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
8909 static inline struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
8910 LDKPositiveTimestamp ret = *owner->contents.result;
8911 ret.is_owned = false;
8914 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_get_ok(uint64_t owner) {
8915 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
8916 LDKPositiveTimestamp ret_var = CResult_PositiveTimestampCreationErrorZ_get_ok(owner_conv);
8917 uint64_t ret_ref = 0;
8918 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8919 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8923 static inline enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
8924 CHECK(!owner->result_ok);
8925 return CreationError_clone(&*owner->contents.err);
8927 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_err"))) TS_CResult_PositiveTimestampCreationErrorZ_get_err(uint64_t owner) {
8928 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
8929 uint32_t ret_conv = LDKCreationError_to_js(CResult_PositiveTimestampCreationErrorZ_get_err(owner_conv));
8933 static inline void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
8934 CHECK(owner->result_ok);
8935 return *owner->contents.result;
8937 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_ok"))) TS_CResult_NoneSemanticErrorZ_get_ok(uint64_t owner) {
8938 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(owner);
8939 CResult_NoneSemanticErrorZ_get_ok(owner_conv);
8942 static inline enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
8943 CHECK(!owner->result_ok);
8944 return SemanticError_clone(&*owner->contents.err);
8946 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_err"))) TS_CResult_NoneSemanticErrorZ_get_err(uint64_t owner) {
8947 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(owner);
8948 uint32_t ret_conv = LDKSemanticError_to_js(CResult_NoneSemanticErrorZ_get_err(owner_conv));
8952 static inline struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
8953 LDKInvoice ret = *owner->contents.result;
8954 ret.is_owned = false;
8957 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_ok"))) TS_CResult_InvoiceSemanticErrorZ_get_ok(uint64_t owner) {
8958 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(owner);
8959 LDKInvoice ret_var = CResult_InvoiceSemanticErrorZ_get_ok(owner_conv);
8960 uint64_t ret_ref = 0;
8961 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8962 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8966 static inline enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
8967 CHECK(!owner->result_ok);
8968 return SemanticError_clone(&*owner->contents.err);
8970 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_err"))) TS_CResult_InvoiceSemanticErrorZ_get_err(uint64_t owner) {
8971 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(owner);
8972 uint32_t ret_conv = LDKSemanticError_to_js(CResult_InvoiceSemanticErrorZ_get_err(owner_conv));
8976 static inline struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
8977 LDKDescription ret = *owner->contents.result;
8978 ret.is_owned = false;
8981 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_ok"))) TS_CResult_DescriptionCreationErrorZ_get_ok(uint64_t owner) {
8982 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
8983 LDKDescription ret_var = CResult_DescriptionCreationErrorZ_get_ok(owner_conv);
8984 uint64_t ret_ref = 0;
8985 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8986 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8990 static inline enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
8991 CHECK(!owner->result_ok);
8992 return CreationError_clone(&*owner->contents.err);
8994 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_err"))) TS_CResult_DescriptionCreationErrorZ_get_err(uint64_t owner) {
8995 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
8996 uint32_t ret_conv = LDKCreationError_to_js(CResult_DescriptionCreationErrorZ_get_err(owner_conv));
9000 static inline struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
9001 LDKPrivateRoute ret = *owner->contents.result;
9002 ret.is_owned = false;
9005 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_ok"))) TS_CResult_PrivateRouteCreationErrorZ_get_ok(uint64_t owner) {
9006 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
9007 LDKPrivateRoute ret_var = CResult_PrivateRouteCreationErrorZ_get_ok(owner_conv);
9008 uint64_t ret_ref = 0;
9009 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
9010 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
9014 static inline enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
9015 CHECK(!owner->result_ok);
9016 return CreationError_clone(&*owner->contents.err);
9018 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_err"))) TS_CResult_PrivateRouteCreationErrorZ_get_err(uint64_t owner) {
9019 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
9020 uint32_t ret_conv = LDKCreationError_to_js(CResult_PrivateRouteCreationErrorZ_get_err(owner_conv));
9024 typedef struct LDKScore_JCalls {
9025 atomic_size_t refcnt;
9026 uint32_t instance_ptr;
9028 static void LDKScore_JCalls_free(void* this_arg) {
9029 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9030 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9034 uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage) {
9035 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9036 int64_t short_channel_id_conv = short_channel_id;
9037 LDKNodeId source_var = *source;
9038 uint64_t source_ref = 0;
9039 source_var = NodeId_clone(&source_var);
9040 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
9041 source_ref = tag_ptr(source_var.inner, source_var.is_owned);
9042 LDKNodeId target_var = *target;
9043 uint64_t target_ref = 0;
9044 target_var = NodeId_clone(&target_var);
9045 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
9046 target_ref = tag_ptr(target_var.inner, target_var.is_owned);
9047 LDKChannelUsage usage_var = usage;
9048 uint64_t usage_ref = 0;
9049 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
9050 usage_ref = tag_ptr(usage_var.inner, usage_var.is_owned);
9051 return js_invoke_function_bbbbuu(j_calls->instance_ptr, 42, short_channel_id_conv, source_ref, target_ref, usage_ref, 0, 0);
9053 void payment_path_failed_LDKScore_jcall(void* this_arg, const LDKPath * path, uint64_t short_channel_id) {
9054 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9055 LDKPath path_var = *path;
9056 uint64_t path_ref = 0;
9057 path_var = Path_clone(&path_var);
9058 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9059 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9060 int64_t short_channel_id_conv = short_channel_id;
9061 js_invoke_function_bbuuuu(j_calls->instance_ptr, 43, path_ref, short_channel_id_conv, 0, 0, 0, 0);
9063 void payment_path_successful_LDKScore_jcall(void* this_arg, const LDKPath * path) {
9064 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9065 LDKPath path_var = *path;
9066 uint64_t path_ref = 0;
9067 path_var = Path_clone(&path_var);
9068 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9069 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9070 js_invoke_function_buuuuu(j_calls->instance_ptr, 44, path_ref, 0, 0, 0, 0, 0);
9072 void probe_failed_LDKScore_jcall(void* this_arg, const LDKPath * path, uint64_t short_channel_id) {
9073 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9074 LDKPath path_var = *path;
9075 uint64_t path_ref = 0;
9076 path_var = Path_clone(&path_var);
9077 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9078 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9079 int64_t short_channel_id_conv = short_channel_id;
9080 js_invoke_function_bbuuuu(j_calls->instance_ptr, 45, path_ref, short_channel_id_conv, 0, 0, 0, 0);
9082 void probe_successful_LDKScore_jcall(void* this_arg, const LDKPath * path) {
9083 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9084 LDKPath path_var = *path;
9085 uint64_t path_ref = 0;
9086 path_var = Path_clone(&path_var);
9087 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9088 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9089 js_invoke_function_buuuuu(j_calls->instance_ptr, 46, path_ref, 0, 0, 0, 0, 0);
9091 LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
9092 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9093 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 47, 0, 0, 0, 0, 0, 0);
9094 LDKCVec_u8Z ret_ref;
9095 ret_ref.datalen = ret->arr_len;
9096 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
9097 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
9100 static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
9101 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
9102 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9104 static inline LDKScore LDKScore_init (JSValue o) {
9105 LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
9106 atomic_init(&calls->refcnt, 1);
9107 calls->instance_ptr = o;
9110 .this_arg = (void*) calls,
9111 .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall,
9112 .payment_path_failed = payment_path_failed_LDKScore_jcall,
9113 .payment_path_successful = payment_path_successful_LDKScore_jcall,
9114 .probe_failed = probe_failed_LDKScore_jcall,
9115 .probe_successful = probe_successful_LDKScore_jcall,
9116 .write = write_LDKScore_jcall,
9117 .free = LDKScore_JCalls_free,
9121 uint64_t __attribute__((export_name("TS_LDKScore_new"))) TS_LDKScore_new(JSValue o) {
9122 LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
9123 *res_ptr = LDKScore_init(o);
9124 return tag_ptr(res_ptr, true);
9126 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) {
9127 void* this_arg_ptr = untag_ptr(this_arg);
9128 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9129 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9130 LDKNodeId source_conv;
9131 source_conv.inner = untag_ptr(source);
9132 source_conv.is_owned = ptr_is_owned(source);
9133 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
9134 source_conv.is_owned = false;
9135 LDKNodeId target_conv;
9136 target_conv.inner = untag_ptr(target);
9137 target_conv.is_owned = ptr_is_owned(target);
9138 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
9139 target_conv.is_owned = false;
9140 LDKChannelUsage usage_conv;
9141 usage_conv.inner = untag_ptr(usage);
9142 usage_conv.is_owned = ptr_is_owned(usage);
9143 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
9144 usage_conv = ChannelUsage_clone(&usage_conv);
9145 int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv);
9149 void __attribute__((export_name("TS_Score_payment_path_failed"))) TS_Score_payment_path_failed(uint64_t this_arg, uint64_t path, int64_t short_channel_id) {
9150 void* this_arg_ptr = untag_ptr(this_arg);
9151 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9152 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9154 path_conv.inner = untag_ptr(path);
9155 path_conv.is_owned = ptr_is_owned(path);
9156 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9157 path_conv.is_owned = false;
9158 (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, &path_conv, short_channel_id);
9161 void __attribute__((export_name("TS_Score_payment_path_successful"))) TS_Score_payment_path_successful(uint64_t this_arg, uint64_t path) {
9162 void* this_arg_ptr = untag_ptr(this_arg);
9163 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9164 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9166 path_conv.inner = untag_ptr(path);
9167 path_conv.is_owned = ptr_is_owned(path);
9168 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9169 path_conv.is_owned = false;
9170 (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, &path_conv);
9173 void __attribute__((export_name("TS_Score_probe_failed"))) TS_Score_probe_failed(uint64_t this_arg, uint64_t path, int64_t short_channel_id) {
9174 void* this_arg_ptr = untag_ptr(this_arg);
9175 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9176 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9178 path_conv.inner = untag_ptr(path);
9179 path_conv.is_owned = ptr_is_owned(path);
9180 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9181 path_conv.is_owned = false;
9182 (this_arg_conv->probe_failed)(this_arg_conv->this_arg, &path_conv, short_channel_id);
9185 void __attribute__((export_name("TS_Score_probe_successful"))) TS_Score_probe_successful(uint64_t this_arg, uint64_t path) {
9186 void* this_arg_ptr = untag_ptr(this_arg);
9187 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9188 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9190 path_conv.inner = untag_ptr(path);
9191 path_conv.is_owned = ptr_is_owned(path);
9192 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9193 path_conv.is_owned = false;
9194 (this_arg_conv->probe_successful)(this_arg_conv->this_arg, &path_conv);
9197 int8_tArray __attribute__((export_name("TS_Score_write"))) TS_Score_write(uint64_t this_arg) {
9198 void* this_arg_ptr = untag_ptr(this_arg);
9199 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9200 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9201 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
9202 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
9203 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
9204 CVec_u8Z_free(ret_var);
9208 typedef struct LDKLockableScore_JCalls {
9209 atomic_size_t refcnt;
9210 uint32_t instance_ptr;
9211 } LDKLockableScore_JCalls;
9212 static void LDKLockableScore_JCalls_free(void* this_arg) {
9213 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
9214 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9218 LDKScore lock_LDKLockableScore_jcall(const void* this_arg) {
9219 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
9220 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 48, 0, 0, 0, 0, 0, 0);
9221 void* ret_ptr = untag_ptr(ret);
9222 CHECK_ACCESS(ret_ptr);
9223 LDKScore ret_conv = *(LDKScore*)(ret_ptr);
9224 if (ret_conv.free == LDKScore_JCalls_free) {
9225 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
9226 LDKScore_JCalls_cloned(&ret_conv);
9227 }// WARNING: we may need a move here but no clone is available for LDKScore
9231 static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
9232 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
9233 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9235 static inline LDKLockableScore LDKLockableScore_init (JSValue o) {
9236 LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
9237 atomic_init(&calls->refcnt, 1);
9238 calls->instance_ptr = o;
9240 LDKLockableScore ret = {
9241 .this_arg = (void*) calls,
9242 .lock = lock_LDKLockableScore_jcall,
9243 .free = LDKLockableScore_JCalls_free,
9247 uint64_t __attribute__((export_name("TS_LDKLockableScore_new"))) TS_LDKLockableScore_new(JSValue o) {
9248 LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
9249 *res_ptr = LDKLockableScore_init(o);
9250 return tag_ptr(res_ptr, true);
9252 uint64_t __attribute__((export_name("TS_LockableScore_lock"))) TS_LockableScore_lock(uint64_t this_arg) {
9253 void* this_arg_ptr = untag_ptr(this_arg);
9254 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9255 LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
9256 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
9257 *ret_ret = (this_arg_conv->lock)(this_arg_conv->this_arg);
9258 return tag_ptr(ret_ret, true);
9261 typedef struct LDKWriteableScore_JCalls {
9262 atomic_size_t refcnt;
9263 uint32_t instance_ptr;
9264 LDKLockableScore_JCalls* LockableScore;
9265 } LDKWriteableScore_JCalls;
9266 static void LDKWriteableScore_JCalls_free(void* this_arg) {
9267 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
9268 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9272 LDKCVec_u8Z write_LDKWriteableScore_jcall(const void* this_arg) {
9273 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
9274 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 49, 0, 0, 0, 0, 0, 0);
9275 LDKCVec_u8Z ret_ref;
9276 ret_ref.datalen = ret->arr_len;
9277 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
9278 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
9281 static void LDKWriteableScore_JCalls_cloned(LDKWriteableScore* new_obj) {
9282 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) new_obj->this_arg;
9283 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9284 atomic_fetch_add_explicit(&j_calls->LockableScore->refcnt, 1, memory_order_release);
9286 static inline LDKWriteableScore LDKWriteableScore_init (JSValue o, JSValue LockableScore) {
9287 LDKWriteableScore_JCalls *calls = MALLOC(sizeof(LDKWriteableScore_JCalls), "LDKWriteableScore_JCalls");
9288 atomic_init(&calls->refcnt, 1);
9289 calls->instance_ptr = o;
9291 LDKWriteableScore ret = {
9292 .this_arg = (void*) calls,
9293 .write = write_LDKWriteableScore_jcall,
9294 .free = LDKWriteableScore_JCalls_free,
9295 .LockableScore = LDKLockableScore_init(LockableScore),
9297 calls->LockableScore = ret.LockableScore.this_arg;
9300 uint64_t __attribute__((export_name("TS_LDKWriteableScore_new"))) TS_LDKWriteableScore_new(JSValue o, JSValue LockableScore) {
9301 LDKWriteableScore *res_ptr = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
9302 *res_ptr = LDKWriteableScore_init(o, LockableScore);
9303 return tag_ptr(res_ptr, true);
9305 int8_tArray __attribute__((export_name("TS_WriteableScore_write"))) TS_WriteableScore_write(uint64_t this_arg) {
9306 void* this_arg_ptr = untag_ptr(this_arg);
9307 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9308 LDKWriteableScore* this_arg_conv = (LDKWriteableScore*)this_arg_ptr;
9309 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
9310 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
9311 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
9312 CVec_u8Z_free(ret_var);
9316 typedef struct LDKPersister_JCalls {
9317 atomic_size_t refcnt;
9318 uint32_t instance_ptr;
9319 } LDKPersister_JCalls;
9320 static void LDKPersister_JCalls_free(void* this_arg) {
9321 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9322 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9326 LDKCResult_NoneErrorZ persist_manager_LDKPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
9327 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9328 LDKChannelManager channel_manager_var = *channel_manager;
9329 uint64_t channel_manager_ref = 0;
9330 // WARNING: we may need a move here but no clone is available for LDKChannelManager
9331 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
9332 channel_manager_ref = tag_ptr(channel_manager_var.inner, channel_manager_var.is_owned);
9333 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 50, channel_manager_ref, 0, 0, 0, 0, 0);
9334 void* ret_ptr = untag_ptr(ret);
9335 CHECK_ACCESS(ret_ptr);
9336 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
9337 FREE(untag_ptr(ret));
9340 LDKCResult_NoneErrorZ persist_graph_LDKPersister_jcall(const void* this_arg, const LDKNetworkGraph * network_graph) {
9341 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9342 LDKNetworkGraph network_graph_var = *network_graph;
9343 uint64_t network_graph_ref = 0;
9344 // WARNING: we may need a move here but no clone is available for LDKNetworkGraph
9345 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_var);
9346 network_graph_ref = tag_ptr(network_graph_var.inner, network_graph_var.is_owned);
9347 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 51, network_graph_ref, 0, 0, 0, 0, 0);
9348 void* ret_ptr = untag_ptr(ret);
9349 CHECK_ACCESS(ret_ptr);
9350 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
9351 FREE(untag_ptr(ret));
9354 LDKCResult_NoneErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKWriteableScore * scorer) {
9355 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9356 // WARNING: This object doesn't live past this scope, needs clone!
9357 uint64_t ret_scorer = tag_ptr(scorer, false);
9358 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 52, ret_scorer, 0, 0, 0, 0, 0);
9359 void* ret_ptr = untag_ptr(ret);
9360 CHECK_ACCESS(ret_ptr);
9361 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
9362 FREE(untag_ptr(ret));
9365 static void LDKPersister_JCalls_cloned(LDKPersister* new_obj) {
9366 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) new_obj->this_arg;
9367 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9369 static inline LDKPersister LDKPersister_init (JSValue o) {
9370 LDKPersister_JCalls *calls = MALLOC(sizeof(LDKPersister_JCalls), "LDKPersister_JCalls");
9371 atomic_init(&calls->refcnt, 1);
9372 calls->instance_ptr = o;
9374 LDKPersister ret = {
9375 .this_arg = (void*) calls,
9376 .persist_manager = persist_manager_LDKPersister_jcall,
9377 .persist_graph = persist_graph_LDKPersister_jcall,
9378 .persist_scorer = persist_scorer_LDKPersister_jcall,
9379 .free = LDKPersister_JCalls_free,
9383 uint64_t __attribute__((export_name("TS_LDKPersister_new"))) TS_LDKPersister_new(JSValue o) {
9384 LDKPersister *res_ptr = MALLOC(sizeof(LDKPersister), "LDKPersister");
9385 *res_ptr = LDKPersister_init(o);
9386 return tag_ptr(res_ptr, true);
9388 uint64_t __attribute__((export_name("TS_Persister_persist_manager"))) TS_Persister_persist_manager(uint64_t this_arg, uint64_t channel_manager) {
9389 void* this_arg_ptr = untag_ptr(this_arg);
9390 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9391 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9392 LDKChannelManager channel_manager_conv;
9393 channel_manager_conv.inner = untag_ptr(channel_manager);
9394 channel_manager_conv.is_owned = ptr_is_owned(channel_manager);
9395 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
9396 channel_manager_conv.is_owned = false;
9397 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9398 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
9399 return tag_ptr(ret_conv, true);
9402 uint64_t __attribute__((export_name("TS_Persister_persist_graph"))) TS_Persister_persist_graph(uint64_t this_arg, uint64_t network_graph) {
9403 void* this_arg_ptr = untag_ptr(this_arg);
9404 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9405 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9406 LDKNetworkGraph network_graph_conv;
9407 network_graph_conv.inner = untag_ptr(network_graph);
9408 network_graph_conv.is_owned = ptr_is_owned(network_graph);
9409 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
9410 network_graph_conv.is_owned = false;
9411 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9412 *ret_conv = (this_arg_conv->persist_graph)(this_arg_conv->this_arg, &network_graph_conv);
9413 return tag_ptr(ret_conv, true);
9416 uint64_t __attribute__((export_name("TS_Persister_persist_scorer"))) TS_Persister_persist_scorer(uint64_t this_arg, uint64_t scorer) {
9417 void* this_arg_ptr = untag_ptr(this_arg);
9418 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9419 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9420 void* scorer_ptr = untag_ptr(scorer);
9421 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
9422 LDKWriteableScore* scorer_conv = (LDKWriteableScore*)scorer_ptr;
9423 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9424 *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, scorer_conv);
9425 return tag_ptr(ret_conv, true);
9428 typedef struct LDKFutureCallback_JCalls {
9429 atomic_size_t refcnt;
9430 uint32_t instance_ptr;
9431 } LDKFutureCallback_JCalls;
9432 static void LDKFutureCallback_JCalls_free(void* this_arg) {
9433 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
9434 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9438 void call_LDKFutureCallback_jcall(const void* this_arg) {
9439 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
9440 js_invoke_function_uuuuuu(j_calls->instance_ptr, 53, 0, 0, 0, 0, 0, 0);
9442 static void LDKFutureCallback_JCalls_cloned(LDKFutureCallback* new_obj) {
9443 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) new_obj->this_arg;
9444 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9446 static inline LDKFutureCallback LDKFutureCallback_init (JSValue o) {
9447 LDKFutureCallback_JCalls *calls = MALLOC(sizeof(LDKFutureCallback_JCalls), "LDKFutureCallback_JCalls");
9448 atomic_init(&calls->refcnt, 1);
9449 calls->instance_ptr = o;
9451 LDKFutureCallback ret = {
9452 .this_arg = (void*) calls,
9453 .call = call_LDKFutureCallback_jcall,
9454 .free = LDKFutureCallback_JCalls_free,
9458 uint64_t __attribute__((export_name("TS_LDKFutureCallback_new"))) TS_LDKFutureCallback_new(JSValue o) {
9459 LDKFutureCallback *res_ptr = MALLOC(sizeof(LDKFutureCallback), "LDKFutureCallback");
9460 *res_ptr = LDKFutureCallback_init(o);
9461 return tag_ptr(res_ptr, true);
9463 void __attribute__((export_name("TS_FutureCallback_call"))) TS_FutureCallback_call(uint64_t this_arg) {
9464 void* this_arg_ptr = untag_ptr(this_arg);
9465 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9466 LDKFutureCallback* this_arg_conv = (LDKFutureCallback*)this_arg_ptr;
9467 (this_arg_conv->call)(this_arg_conv->this_arg);
9470 typedef struct LDKListen_JCalls {
9471 atomic_size_t refcnt;
9472 uint32_t instance_ptr;
9474 static void LDKListen_JCalls_free(void* this_arg) {
9475 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9476 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9480 void filtered_block_connected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9481 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9482 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9483 memcpy(header_arr->elems, *header, 80);
9484 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9485 uint64_tArray txdata_arr = NULL;
9486 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
9487 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
9488 for (size_t c = 0; c < txdata_var.datalen; c++) {
9489 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9490 *txdata_conv_28_conv = txdata_var.data[c];
9491 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
9494 FREE(txdata_var.data);
9495 int32_t height_conv = height;
9496 js_invoke_function_uuuuuu(j_calls->instance_ptr, 54, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
9498 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
9499 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9500 LDKu8slice block_var = block;
9501 int8_tArray block_arr = init_int8_tArray(block_var.datalen, __LINE__);
9502 memcpy(block_arr->elems, block_var.data, block_var.datalen);
9503 int32_t height_conv = height;
9504 js_invoke_function_uuuuuu(j_calls->instance_ptr, 55, (uint32_t)block_arr, height_conv, 0, 0, 0, 0);
9506 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9507 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9508 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9509 memcpy(header_arr->elems, *header, 80);
9510 int32_t height_conv = height;
9511 js_invoke_function_uuuuuu(j_calls->instance_ptr, 56, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
9513 static void LDKListen_JCalls_cloned(LDKListen* new_obj) {
9514 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) new_obj->this_arg;
9515 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9517 static inline LDKListen LDKListen_init (JSValue o) {
9518 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
9519 atomic_init(&calls->refcnt, 1);
9520 calls->instance_ptr = o;
9523 .this_arg = (void*) calls,
9524 .filtered_block_connected = filtered_block_connected_LDKListen_jcall,
9525 .block_connected = block_connected_LDKListen_jcall,
9526 .block_disconnected = block_disconnected_LDKListen_jcall,
9527 .free = LDKListen_JCalls_free,
9531 uint64_t __attribute__((export_name("TS_LDKListen_new"))) TS_LDKListen_new(JSValue o) {
9532 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
9533 *res_ptr = LDKListen_init(o);
9534 return tag_ptr(res_ptr, true);
9536 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) {
9537 void* this_arg_ptr = untag_ptr(this_arg);
9538 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9539 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9540 uint8_t header_arr[80];
9541 CHECK(header->arr_len == 80);
9542 memcpy(header_arr, header->elems, 80); FREE(header);
9543 uint8_t (*header_ref)[80] = &header_arr;
9544 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9545 txdata_constr.datalen = txdata->arr_len;
9546 if (txdata_constr.datalen > 0)
9547 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9549 txdata_constr.data = NULL;
9550 uint64_t* txdata_vals = txdata->elems;
9551 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9552 uint64_t txdata_conv_28 = txdata_vals[c];
9553 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
9554 CHECK_ACCESS(txdata_conv_28_ptr);
9555 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9556 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
9557 txdata_constr.data[c] = txdata_conv_28_conv;
9560 (this_arg_conv->filtered_block_connected)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9563 void __attribute__((export_name("TS_Listen_block_connected"))) TS_Listen_block_connected(uint64_t this_arg, int8_tArray block, int32_t height) {
9564 void* this_arg_ptr = untag_ptr(this_arg);
9565 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9566 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9567 LDKu8slice block_ref;
9568 block_ref.datalen = block->arr_len;
9569 block_ref.data = block->elems;
9570 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
9574 void __attribute__((export_name("TS_Listen_block_disconnected"))) TS_Listen_block_disconnected(uint64_t this_arg, int8_tArray header, int32_t height) {
9575 void* this_arg_ptr = untag_ptr(this_arg);
9576 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9577 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9578 uint8_t header_arr[80];
9579 CHECK(header->arr_len == 80);
9580 memcpy(header_arr, header->elems, 80); FREE(header);
9581 uint8_t (*header_ref)[80] = &header_arr;
9582 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
9585 typedef struct LDKConfirm_JCalls {
9586 atomic_size_t refcnt;
9587 uint32_t instance_ptr;
9588 } LDKConfirm_JCalls;
9589 static void LDKConfirm_JCalls_free(void* this_arg) {
9590 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9591 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9595 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9596 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9597 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9598 memcpy(header_arr->elems, *header, 80);
9599 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9600 uint64_tArray txdata_arr = NULL;
9601 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
9602 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
9603 for (size_t c = 0; c < txdata_var.datalen; c++) {
9604 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9605 *txdata_conv_28_conv = txdata_var.data[c];
9606 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
9609 FREE(txdata_var.data);
9610 int32_t height_conv = height;
9611 js_invoke_function_uuuuuu(j_calls->instance_ptr, 57, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
9613 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
9614 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9615 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
9616 memcpy(txid_arr->elems, *txid, 32);
9617 js_invoke_function_uuuuuu(j_calls->instance_ptr, 58, (uint32_t)txid_arr, 0, 0, 0, 0, 0);
9619 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9620 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9621 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9622 memcpy(header_arr->elems, *header, 80);
9623 int32_t height_conv = height;
9624 js_invoke_function_uuuuuu(j_calls->instance_ptr, 59, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
9626 LDKCVec_C2Tuple_TxidBlockHashZZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
9627 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9628 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 60, 0, 0, 0, 0, 0, 0);
9629 LDKCVec_C2Tuple_TxidBlockHashZZ ret_constr;
9630 ret_constr.datalen = ret->arr_len;
9631 if (ret_constr.datalen > 0)
9632 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKCVec_C2Tuple_TxidBlockHashZZ Elements");
9634 ret_constr.data = NULL;
9635 uint64_t* ret_vals = ret->elems;
9636 for (size_t z = 0; z < ret_constr.datalen; z++) {
9637 uint64_t ret_conv_25 = ret_vals[z];
9638 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
9639 CHECK_ACCESS(ret_conv_25_ptr);
9640 LDKC2Tuple_TxidBlockHashZ ret_conv_25_conv = *(LDKC2Tuple_TxidBlockHashZ*)(ret_conv_25_ptr);
9641 FREE(untag_ptr(ret_conv_25));
9642 ret_constr.data[z] = ret_conv_25_conv;
9647 static void LDKConfirm_JCalls_cloned(LDKConfirm* new_obj) {
9648 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) new_obj->this_arg;
9649 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9651 static inline LDKConfirm LDKConfirm_init (JSValue o) {
9652 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
9653 atomic_init(&calls->refcnt, 1);
9654 calls->instance_ptr = o;
9657 .this_arg = (void*) calls,
9658 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
9659 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
9660 .best_block_updated = best_block_updated_LDKConfirm_jcall,
9661 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
9662 .free = LDKConfirm_JCalls_free,
9666 uint64_t __attribute__((export_name("TS_LDKConfirm_new"))) TS_LDKConfirm_new(JSValue o) {
9667 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
9668 *res_ptr = LDKConfirm_init(o);
9669 return tag_ptr(res_ptr, true);
9671 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) {
9672 void* this_arg_ptr = untag_ptr(this_arg);
9673 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9674 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9675 uint8_t header_arr[80];
9676 CHECK(header->arr_len == 80);
9677 memcpy(header_arr, header->elems, 80); FREE(header);
9678 uint8_t (*header_ref)[80] = &header_arr;
9679 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9680 txdata_constr.datalen = txdata->arr_len;
9681 if (txdata_constr.datalen > 0)
9682 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9684 txdata_constr.data = NULL;
9685 uint64_t* txdata_vals = txdata->elems;
9686 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9687 uint64_t txdata_conv_28 = txdata_vals[c];
9688 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
9689 CHECK_ACCESS(txdata_conv_28_ptr);
9690 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9691 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
9692 txdata_constr.data[c] = txdata_conv_28_conv;
9695 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9698 void __attribute__((export_name("TS_Confirm_transaction_unconfirmed"))) TS_Confirm_transaction_unconfirmed(uint64_t this_arg, int8_tArray txid) {
9699 void* this_arg_ptr = untag_ptr(this_arg);
9700 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9701 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9702 uint8_t txid_arr[32];
9703 CHECK(txid->arr_len == 32);
9704 memcpy(txid_arr, txid->elems, 32); FREE(txid);
9705 uint8_t (*txid_ref)[32] = &txid_arr;
9706 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
9709 void __attribute__((export_name("TS_Confirm_best_block_updated"))) TS_Confirm_best_block_updated(uint64_t this_arg, int8_tArray header, int32_t height) {
9710 void* this_arg_ptr = untag_ptr(this_arg);
9711 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9712 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9713 uint8_t header_arr[80];
9714 CHECK(header->arr_len == 80);
9715 memcpy(header_arr, header->elems, 80); FREE(header);
9716 uint8_t (*header_ref)[80] = &header_arr;
9717 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
9720 uint64_tArray __attribute__((export_name("TS_Confirm_get_relevant_txids"))) TS_Confirm_get_relevant_txids(uint64_t this_arg) {
9721 void* this_arg_ptr = untag_ptr(this_arg);
9722 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9723 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9724 LDKCVec_C2Tuple_TxidBlockHashZZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
9725 uint64_tArray ret_arr = NULL;
9726 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
9727 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
9728 for (size_t z = 0; z < ret_var.datalen; z++) {
9729 LDKC2Tuple_TxidBlockHashZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
9730 *ret_conv_25_conv = ret_var.data[z];
9731 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
9738 typedef struct LDKPersist_JCalls {
9739 atomic_size_t refcnt;
9740 uint32_t instance_ptr;
9741 } LDKPersist_JCalls;
9742 static void LDKPersist_JCalls_free(void* this_arg) {
9743 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9744 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9748 LDKChannelMonitorUpdateStatus persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9749 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9750 LDKOutPoint channel_id_var = channel_id;
9751 uint64_t channel_id_ref = 0;
9752 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9753 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
9754 LDKChannelMonitor data_var = *data;
9755 uint64_t data_ref = 0;
9756 data_var = ChannelMonitor_clone(&data_var);
9757 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9758 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
9759 LDKMonitorUpdateId update_id_var = update_id;
9760 uint64_t update_id_ref = 0;
9761 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9762 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
9763 uint64_t ret = js_invoke_function_bbbuuu(j_calls->instance_ptr, 61, channel_id_ref, data_ref, update_id_ref, 0, 0, 0);
9764 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
9767 LDKChannelMonitorUpdateStatus update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, LDKChannelMonitorUpdate update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9768 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9769 LDKOutPoint channel_id_var = channel_id;
9770 uint64_t channel_id_ref = 0;
9771 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9772 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
9773 LDKChannelMonitorUpdate update_var = update;
9774 uint64_t update_ref = 0;
9775 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
9776 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
9777 LDKChannelMonitor data_var = *data;
9778 uint64_t data_ref = 0;
9779 data_var = ChannelMonitor_clone(&data_var);
9780 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9781 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
9782 LDKMonitorUpdateId update_id_var = update_id;
9783 uint64_t update_id_ref = 0;
9784 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9785 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
9786 uint64_t ret = js_invoke_function_bbbbuu(j_calls->instance_ptr, 62, channel_id_ref, update_ref, data_ref, update_id_ref, 0, 0);
9787 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
9790 static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
9791 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) new_obj->this_arg;
9792 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9794 static inline LDKPersist LDKPersist_init (JSValue o) {
9795 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
9796 atomic_init(&calls->refcnt, 1);
9797 calls->instance_ptr = o;
9800 .this_arg = (void*) calls,
9801 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
9802 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
9803 .free = LDKPersist_JCalls_free,
9807 uint64_t __attribute__((export_name("TS_LDKPersist_new"))) TS_LDKPersist_new(JSValue o) {
9808 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
9809 *res_ptr = LDKPersist_init(o);
9810 return tag_ptr(res_ptr, true);
9812 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) {
9813 void* this_arg_ptr = untag_ptr(this_arg);
9814 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9815 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9816 LDKOutPoint channel_id_conv;
9817 channel_id_conv.inner = untag_ptr(channel_id);
9818 channel_id_conv.is_owned = ptr_is_owned(channel_id);
9819 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9820 channel_id_conv = OutPoint_clone(&channel_id_conv);
9821 LDKChannelMonitor data_conv;
9822 data_conv.inner = untag_ptr(data);
9823 data_conv.is_owned = ptr_is_owned(data);
9824 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9825 data_conv.is_owned = false;
9826 LDKMonitorUpdateId update_id_conv;
9827 update_id_conv.inner = untag_ptr(update_id);
9828 update_id_conv.is_owned = ptr_is_owned(update_id);
9829 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9830 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9831 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));
9835 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) {
9836 void* this_arg_ptr = untag_ptr(this_arg);
9837 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9838 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9839 LDKOutPoint channel_id_conv;
9840 channel_id_conv.inner = untag_ptr(channel_id);
9841 channel_id_conv.is_owned = ptr_is_owned(channel_id);
9842 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9843 channel_id_conv = OutPoint_clone(&channel_id_conv);
9844 LDKChannelMonitorUpdate update_conv;
9845 update_conv.inner = untag_ptr(update);
9846 update_conv.is_owned = ptr_is_owned(update);
9847 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
9848 update_conv = ChannelMonitorUpdate_clone(&update_conv);
9849 LDKChannelMonitor data_conv;
9850 data_conv.inner = untag_ptr(data);
9851 data_conv.is_owned = ptr_is_owned(data);
9852 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9853 data_conv.is_owned = false;
9854 LDKMonitorUpdateId update_id_conv;
9855 update_id_conv.inner = untag_ptr(update_id);
9856 update_id_conv.is_owned = ptr_is_owned(update_id);
9857 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9858 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9859 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));
9863 typedef struct LDKEventHandler_JCalls {
9864 atomic_size_t refcnt;
9865 uint32_t instance_ptr;
9866 } LDKEventHandler_JCalls;
9867 static void LDKEventHandler_JCalls_free(void* this_arg) {
9868 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
9869 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9873 void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) {
9874 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
9875 LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
9876 *event_copy = event;
9877 uint64_t event_ref = tag_ptr(event_copy, true);
9878 js_invoke_function_buuuuu(j_calls->instance_ptr, 63, event_ref, 0, 0, 0, 0, 0);
9880 static void LDKEventHandler_JCalls_cloned(LDKEventHandler* new_obj) {
9881 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) new_obj->this_arg;
9882 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9884 static inline LDKEventHandler LDKEventHandler_init (JSValue o) {
9885 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
9886 atomic_init(&calls->refcnt, 1);
9887 calls->instance_ptr = o;
9889 LDKEventHandler ret = {
9890 .this_arg = (void*) calls,
9891 .handle_event = handle_event_LDKEventHandler_jcall,
9892 .free = LDKEventHandler_JCalls_free,
9896 uint64_t __attribute__((export_name("TS_LDKEventHandler_new"))) TS_LDKEventHandler_new(JSValue o) {
9897 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
9898 *res_ptr = LDKEventHandler_init(o);
9899 return tag_ptr(res_ptr, true);
9901 void __attribute__((export_name("TS_EventHandler_handle_event"))) TS_EventHandler_handle_event(uint64_t this_arg, uint64_t event) {
9902 void* this_arg_ptr = untag_ptr(this_arg);
9903 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9904 LDKEventHandler* this_arg_conv = (LDKEventHandler*)this_arg_ptr;
9905 void* event_ptr = untag_ptr(event);
9906 CHECK_ACCESS(event_ptr);
9907 LDKEvent event_conv = *(LDKEvent*)(event_ptr);
9908 event_conv = Event_clone((LDKEvent*)untag_ptr(event));
9909 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
9912 typedef struct LDKEventsProvider_JCalls {
9913 atomic_size_t refcnt;
9914 uint32_t instance_ptr;
9915 } LDKEventsProvider_JCalls;
9916 static void LDKEventsProvider_JCalls_free(void* this_arg) {
9917 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
9918 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9922 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
9923 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
9924 LDKEventHandler* handler_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
9925 *handler_ret = handler;
9926 js_invoke_function_buuuuu(j_calls->instance_ptr, 64, tag_ptr(handler_ret, true), 0, 0, 0, 0, 0);
9928 static void LDKEventsProvider_JCalls_cloned(LDKEventsProvider* new_obj) {
9929 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) new_obj->this_arg;
9930 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9932 static inline LDKEventsProvider LDKEventsProvider_init (JSValue o) {
9933 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
9934 atomic_init(&calls->refcnt, 1);
9935 calls->instance_ptr = o;
9937 LDKEventsProvider ret = {
9938 .this_arg = (void*) calls,
9939 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
9940 .free = LDKEventsProvider_JCalls_free,
9944 uint64_t __attribute__((export_name("TS_LDKEventsProvider_new"))) TS_LDKEventsProvider_new(JSValue o) {
9945 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
9946 *res_ptr = LDKEventsProvider_init(o);
9947 return tag_ptr(res_ptr, true);
9949 void __attribute__((export_name("TS_EventsProvider_process_pending_events"))) TS_EventsProvider_process_pending_events(uint64_t this_arg, uint64_t handler) {
9950 void* this_arg_ptr = untag_ptr(this_arg);
9951 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9952 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)this_arg_ptr;
9953 void* handler_ptr = untag_ptr(handler);
9954 CHECK_ACCESS(handler_ptr);
9955 LDKEventHandler handler_conv = *(LDKEventHandler*)(handler_ptr);
9956 if (handler_conv.free == LDKEventHandler_JCalls_free) {
9957 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
9958 LDKEventHandler_JCalls_cloned(&handler_conv);
9960 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
9963 uint32_t __attribute__((export_name("TS_LDKRetry_ty_from_ptr"))) TS_LDKRetry_ty_from_ptr(uint64_t ptr) {
9964 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
9966 case LDKRetry_Attempts: return 0;
9970 uint32_t __attribute__((export_name("TS_LDKRetry_Attempts_get_attempts"))) TS_LDKRetry_Attempts_get_attempts(uint64_t ptr) {
9971 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
9972 assert(obj->tag == LDKRetry_Attempts);
9973 uint32_t attempts_conv = obj->attempts;
9974 return attempts_conv;
9976 typedef struct LDKMessageSendEventsProvider_JCalls {
9977 atomic_size_t refcnt;
9978 uint32_t instance_ptr;
9979 } LDKMessageSendEventsProvider_JCalls;
9980 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
9981 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
9982 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9986 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
9987 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
9988 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 65, 0, 0, 0, 0, 0, 0);
9989 LDKCVec_MessageSendEventZ ret_constr;
9990 ret_constr.datalen = ret->arr_len;
9991 if (ret_constr.datalen > 0)
9992 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
9994 ret_constr.data = NULL;
9995 uint64_t* ret_vals = ret->elems;
9996 for (size_t s = 0; s < ret_constr.datalen; s++) {
9997 uint64_t ret_conv_18 = ret_vals[s];
9998 void* ret_conv_18_ptr = untag_ptr(ret_conv_18);
9999 CHECK_ACCESS(ret_conv_18_ptr);
10000 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
10001 FREE(untag_ptr(ret_conv_18));
10002 ret_constr.data[s] = ret_conv_18_conv;
10007 static void LDKMessageSendEventsProvider_JCalls_cloned(LDKMessageSendEventsProvider* new_obj) {
10008 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) new_obj->this_arg;
10009 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10011 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JSValue o) {
10012 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
10013 atomic_init(&calls->refcnt, 1);
10014 calls->instance_ptr = o;
10016 LDKMessageSendEventsProvider ret = {
10017 .this_arg = (void*) calls,
10018 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
10019 .free = LDKMessageSendEventsProvider_JCalls_free,
10023 uint64_t __attribute__((export_name("TS_LDKMessageSendEventsProvider_new"))) TS_LDKMessageSendEventsProvider_new(JSValue o) {
10024 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
10025 *res_ptr = LDKMessageSendEventsProvider_init(o);
10026 return tag_ptr(res_ptr, true);
10028 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) {
10029 void* this_arg_ptr = untag_ptr(this_arg);
10030 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10031 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)this_arg_ptr;
10032 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
10033 uint64_tArray ret_arr = NULL;
10034 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
10035 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
10036 for (size_t s = 0; s < ret_var.datalen; s++) {
10037 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
10038 *ret_conv_18_copy = ret_var.data[s];
10039 uint64_t ret_conv_18_ref = tag_ptr(ret_conv_18_copy, true);
10040 ret_arr_ptr[s] = ret_conv_18_ref;
10043 FREE(ret_var.data);
10047 typedef struct LDKChannelMessageHandler_JCalls {
10048 atomic_size_t refcnt;
10049 uint32_t instance_ptr;
10050 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
10051 } LDKChannelMessageHandler_JCalls;
10052 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
10053 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10054 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10058 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKOpenChannel * msg) {
10059 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10060 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10061 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10062 LDKOpenChannel msg_var = *msg;
10063 uint64_t msg_ref = 0;
10064 msg_var = OpenChannel_clone(&msg_var);
10065 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10066 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10067 js_invoke_function_ubuuuu(j_calls->instance_ptr, 66, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10069 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAcceptChannel * msg) {
10070 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10071 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10072 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10073 LDKAcceptChannel msg_var = *msg;
10074 uint64_t msg_ref = 0;
10075 msg_var = AcceptChannel_clone(&msg_var);
10076 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10077 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10078 js_invoke_function_ubuuuu(j_calls->instance_ptr, 67, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10080 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
10081 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10082 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10083 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10084 LDKFundingCreated msg_var = *msg;
10085 uint64_t msg_ref = 0;
10086 msg_var = FundingCreated_clone(&msg_var);
10087 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10088 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10089 js_invoke_function_ubuuuu(j_calls->instance_ptr, 68, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10091 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
10092 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10093 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10094 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10095 LDKFundingSigned msg_var = *msg;
10096 uint64_t msg_ref = 0;
10097 msg_var = FundingSigned_clone(&msg_var);
10098 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10099 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10100 js_invoke_function_ubuuuu(j_calls->instance_ptr, 69, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10102 void handle_channel_ready_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReady * msg) {
10103 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10104 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10105 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10106 LDKChannelReady msg_var = *msg;
10107 uint64_t msg_ref = 0;
10108 msg_var = ChannelReady_clone(&msg_var);
10109 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10110 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10111 js_invoke_function_ubuuuu(j_calls->instance_ptr, 70, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10113 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKShutdown * msg) {
10114 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10115 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10116 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10117 LDKShutdown msg_var = *msg;
10118 uint64_t msg_ref = 0;
10119 msg_var = Shutdown_clone(&msg_var);
10120 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10121 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10122 js_invoke_function_ubuuuu(j_calls->instance_ptr, 71, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10124 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
10125 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10126 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10127 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10128 LDKClosingSigned msg_var = *msg;
10129 uint64_t msg_ref = 0;
10130 msg_var = ClosingSigned_clone(&msg_var);
10131 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10132 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10133 js_invoke_function_ubuuuu(j_calls->instance_ptr, 72, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10135 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
10136 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10137 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10138 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10139 LDKUpdateAddHTLC msg_var = *msg;
10140 uint64_t msg_ref = 0;
10141 msg_var = UpdateAddHTLC_clone(&msg_var);
10142 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10143 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10144 js_invoke_function_ubuuuu(j_calls->instance_ptr, 73, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10146 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
10147 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10148 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10149 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10150 LDKUpdateFulfillHTLC msg_var = *msg;
10151 uint64_t msg_ref = 0;
10152 msg_var = UpdateFulfillHTLC_clone(&msg_var);
10153 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10154 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10155 js_invoke_function_ubuuuu(j_calls->instance_ptr, 74, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10157 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
10158 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10159 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10160 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10161 LDKUpdateFailHTLC msg_var = *msg;
10162 uint64_t msg_ref = 0;
10163 msg_var = UpdateFailHTLC_clone(&msg_var);
10164 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10165 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10166 js_invoke_function_ubuuuu(j_calls->instance_ptr, 75, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10168 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
10169 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10170 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10171 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10172 LDKUpdateFailMalformedHTLC msg_var = *msg;
10173 uint64_t msg_ref = 0;
10174 msg_var = UpdateFailMalformedHTLC_clone(&msg_var);
10175 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10176 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10177 js_invoke_function_ubuuuu(j_calls->instance_ptr, 76, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10179 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
10180 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10181 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10182 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10183 LDKCommitmentSigned msg_var = *msg;
10184 uint64_t msg_ref = 0;
10185 msg_var = CommitmentSigned_clone(&msg_var);
10186 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10187 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10188 js_invoke_function_ubuuuu(j_calls->instance_ptr, 77, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10190 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
10191 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10192 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10193 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10194 LDKRevokeAndACK msg_var = *msg;
10195 uint64_t msg_ref = 0;
10196 msg_var = RevokeAndACK_clone(&msg_var);
10197 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10198 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10199 js_invoke_function_ubuuuu(j_calls->instance_ptr, 78, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10201 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
10202 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10203 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10204 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10205 LDKUpdateFee msg_var = *msg;
10206 uint64_t msg_ref = 0;
10207 msg_var = UpdateFee_clone(&msg_var);
10208 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10209 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10210 js_invoke_function_ubuuuu(j_calls->instance_ptr, 79, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10212 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
10213 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10214 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10215 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10216 LDKAnnouncementSignatures msg_var = *msg;
10217 uint64_t msg_ref = 0;
10218 msg_var = AnnouncementSignatures_clone(&msg_var);
10219 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10220 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10221 js_invoke_function_ubuuuu(j_calls->instance_ptr, 80, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10223 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10224 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10225 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10226 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10227 js_invoke_function_uuuuuu(j_calls->instance_ptr, 81, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10229 LDKCResult_NoneNoneZ peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg, bool inbound) {
10230 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10231 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10232 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10233 LDKInit msg_var = *msg;
10234 uint64_t msg_ref = 0;
10235 msg_var = Init_clone(&msg_var);
10236 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10237 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10238 jboolean inbound_conv = inbound;
10239 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 82, (uint32_t)their_node_id_arr, msg_ref, inbound_conv, 0, 0, 0);
10240 void* ret_ptr = untag_ptr(ret);
10241 CHECK_ACCESS(ret_ptr);
10242 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
10243 FREE(untag_ptr(ret));
10246 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
10247 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10248 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10249 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10250 LDKChannelReestablish msg_var = *msg;
10251 uint64_t msg_ref = 0;
10252 msg_var = ChannelReestablish_clone(&msg_var);
10253 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10254 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10255 js_invoke_function_ubuuuu(j_calls->instance_ptr, 83, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10257 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
10258 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10259 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10260 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10261 LDKChannelUpdate msg_var = *msg;
10262 uint64_t msg_ref = 0;
10263 msg_var = ChannelUpdate_clone(&msg_var);
10264 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10265 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10266 js_invoke_function_ubuuuu(j_calls->instance_ptr, 84, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10268 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
10269 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10270 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10271 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10272 LDKErrorMessage msg_var = *msg;
10273 uint64_t msg_ref = 0;
10274 msg_var = ErrorMessage_clone(&msg_var);
10275 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10276 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10277 js_invoke_function_ubuuuu(j_calls->instance_ptr, 85, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10279 LDKNodeFeatures provided_node_features_LDKChannelMessageHandler_jcall(const void* this_arg) {
10280 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10281 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 86, 0, 0, 0, 0, 0, 0);
10282 LDKNodeFeatures ret_conv;
10283 ret_conv.inner = untag_ptr(ret);
10284 ret_conv.is_owned = ptr_is_owned(ret);
10285 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10288 LDKInitFeatures provided_init_features_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10289 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10290 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10291 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10292 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 87, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10293 LDKInitFeatures ret_conv;
10294 ret_conv.inner = untag_ptr(ret);
10295 ret_conv.is_owned = ptr_is_owned(ret);
10296 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10299 static void LDKChannelMessageHandler_JCalls_cloned(LDKChannelMessageHandler* new_obj) {
10300 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) new_obj->this_arg;
10301 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10302 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
10304 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
10305 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
10306 atomic_init(&calls->refcnt, 1);
10307 calls->instance_ptr = o;
10309 LDKChannelMessageHandler ret = {
10310 .this_arg = (void*) calls,
10311 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
10312 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
10313 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
10314 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
10315 .handle_channel_ready = handle_channel_ready_LDKChannelMessageHandler_jcall,
10316 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
10317 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
10318 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
10319 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
10320 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
10321 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
10322 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
10323 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
10324 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
10325 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
10326 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
10327 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
10328 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
10329 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
10330 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
10331 .provided_node_features = provided_node_features_LDKChannelMessageHandler_jcall,
10332 .provided_init_features = provided_init_features_LDKChannelMessageHandler_jcall,
10333 .free = LDKChannelMessageHandler_JCalls_free,
10334 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
10336 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
10339 uint64_t __attribute__((export_name("TS_LDKChannelMessageHandler_new"))) TS_LDKChannelMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
10340 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
10341 *res_ptr = LDKChannelMessageHandler_init(o, MessageSendEventsProvider);
10342 return tag_ptr(res_ptr, true);
10344 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 msg) {
10345 void* this_arg_ptr = untag_ptr(this_arg);
10346 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10347 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10348 LDKPublicKey their_node_id_ref;
10349 CHECK(their_node_id->arr_len == 33);
10350 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10351 LDKOpenChannel msg_conv;
10352 msg_conv.inner = untag_ptr(msg);
10353 msg_conv.is_owned = ptr_is_owned(msg);
10354 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10355 msg_conv.is_owned = false;
10356 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10359 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 msg) {
10360 void* this_arg_ptr = untag_ptr(this_arg);
10361 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10362 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10363 LDKPublicKey their_node_id_ref;
10364 CHECK(their_node_id->arr_len == 33);
10365 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10366 LDKAcceptChannel msg_conv;
10367 msg_conv.inner = untag_ptr(msg);
10368 msg_conv.is_owned = ptr_is_owned(msg);
10369 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10370 msg_conv.is_owned = false;
10371 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10374 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) {
10375 void* this_arg_ptr = untag_ptr(this_arg);
10376 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10377 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10378 LDKPublicKey their_node_id_ref;
10379 CHECK(their_node_id->arr_len == 33);
10380 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10381 LDKFundingCreated msg_conv;
10382 msg_conv.inner = untag_ptr(msg);
10383 msg_conv.is_owned = ptr_is_owned(msg);
10384 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10385 msg_conv.is_owned = false;
10386 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10389 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) {
10390 void* this_arg_ptr = untag_ptr(this_arg);
10391 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10392 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10393 LDKPublicKey their_node_id_ref;
10394 CHECK(their_node_id->arr_len == 33);
10395 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10396 LDKFundingSigned msg_conv;
10397 msg_conv.inner = untag_ptr(msg);
10398 msg_conv.is_owned = ptr_is_owned(msg);
10399 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10400 msg_conv.is_owned = false;
10401 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10404 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) {
10405 void* this_arg_ptr = untag_ptr(this_arg);
10406 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10407 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10408 LDKPublicKey their_node_id_ref;
10409 CHECK(their_node_id->arr_len == 33);
10410 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10411 LDKChannelReady msg_conv;
10412 msg_conv.inner = untag_ptr(msg);
10413 msg_conv.is_owned = ptr_is_owned(msg);
10414 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10415 msg_conv.is_owned = false;
10416 (this_arg_conv->handle_channel_ready)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10419 void __attribute__((export_name("TS_ChannelMessageHandler_handle_shutdown"))) TS_ChannelMessageHandler_handle_shutdown(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10420 void* this_arg_ptr = untag_ptr(this_arg);
10421 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10422 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10423 LDKPublicKey their_node_id_ref;
10424 CHECK(their_node_id->arr_len == 33);
10425 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10426 LDKShutdown msg_conv;
10427 msg_conv.inner = untag_ptr(msg);
10428 msg_conv.is_owned = ptr_is_owned(msg);
10429 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10430 msg_conv.is_owned = false;
10431 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10434 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) {
10435 void* this_arg_ptr = untag_ptr(this_arg);
10436 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10437 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10438 LDKPublicKey their_node_id_ref;
10439 CHECK(their_node_id->arr_len == 33);
10440 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10441 LDKClosingSigned msg_conv;
10442 msg_conv.inner = untag_ptr(msg);
10443 msg_conv.is_owned = ptr_is_owned(msg);
10444 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10445 msg_conv.is_owned = false;
10446 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10449 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) {
10450 void* this_arg_ptr = untag_ptr(this_arg);
10451 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10452 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10453 LDKPublicKey their_node_id_ref;
10454 CHECK(their_node_id->arr_len == 33);
10455 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10456 LDKUpdateAddHTLC msg_conv;
10457 msg_conv.inner = untag_ptr(msg);
10458 msg_conv.is_owned = ptr_is_owned(msg);
10459 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10460 msg_conv.is_owned = false;
10461 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10464 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) {
10465 void* this_arg_ptr = untag_ptr(this_arg);
10466 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10467 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10468 LDKPublicKey their_node_id_ref;
10469 CHECK(their_node_id->arr_len == 33);
10470 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10471 LDKUpdateFulfillHTLC msg_conv;
10472 msg_conv.inner = untag_ptr(msg);
10473 msg_conv.is_owned = ptr_is_owned(msg);
10474 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10475 msg_conv.is_owned = false;
10476 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10479 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) {
10480 void* this_arg_ptr = untag_ptr(this_arg);
10481 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10482 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10483 LDKPublicKey their_node_id_ref;
10484 CHECK(their_node_id->arr_len == 33);
10485 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10486 LDKUpdateFailHTLC msg_conv;
10487 msg_conv.inner = untag_ptr(msg);
10488 msg_conv.is_owned = ptr_is_owned(msg);
10489 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10490 msg_conv.is_owned = false;
10491 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10494 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) {
10495 void* this_arg_ptr = untag_ptr(this_arg);
10496 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10497 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10498 LDKPublicKey their_node_id_ref;
10499 CHECK(their_node_id->arr_len == 33);
10500 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10501 LDKUpdateFailMalformedHTLC msg_conv;
10502 msg_conv.inner = untag_ptr(msg);
10503 msg_conv.is_owned = ptr_is_owned(msg);
10504 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10505 msg_conv.is_owned = false;
10506 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10509 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) {
10510 void* this_arg_ptr = untag_ptr(this_arg);
10511 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10512 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10513 LDKPublicKey their_node_id_ref;
10514 CHECK(their_node_id->arr_len == 33);
10515 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10516 LDKCommitmentSigned msg_conv;
10517 msg_conv.inner = untag_ptr(msg);
10518 msg_conv.is_owned = ptr_is_owned(msg);
10519 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10520 msg_conv.is_owned = false;
10521 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10524 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) {
10525 void* this_arg_ptr = untag_ptr(this_arg);
10526 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10527 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10528 LDKPublicKey their_node_id_ref;
10529 CHECK(their_node_id->arr_len == 33);
10530 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10531 LDKRevokeAndACK msg_conv;
10532 msg_conv.inner = untag_ptr(msg);
10533 msg_conv.is_owned = ptr_is_owned(msg);
10534 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10535 msg_conv.is_owned = false;
10536 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10539 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) {
10540 void* this_arg_ptr = untag_ptr(this_arg);
10541 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10542 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10543 LDKPublicKey their_node_id_ref;
10544 CHECK(their_node_id->arr_len == 33);
10545 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10546 LDKUpdateFee msg_conv;
10547 msg_conv.inner = untag_ptr(msg);
10548 msg_conv.is_owned = ptr_is_owned(msg);
10549 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10550 msg_conv.is_owned = false;
10551 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10554 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) {
10555 void* this_arg_ptr = untag_ptr(this_arg);
10556 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10557 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10558 LDKPublicKey their_node_id_ref;
10559 CHECK(their_node_id->arr_len == 33);
10560 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10561 LDKAnnouncementSignatures msg_conv;
10562 msg_conv.inner = untag_ptr(msg);
10563 msg_conv.is_owned = ptr_is_owned(msg);
10564 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10565 msg_conv.is_owned = false;
10566 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10569 void __attribute__((export_name("TS_ChannelMessageHandler_peer_disconnected"))) TS_ChannelMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id) {
10570 void* this_arg_ptr = untag_ptr(this_arg);
10571 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10572 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10573 LDKPublicKey their_node_id_ref;
10574 CHECK(their_node_id->arr_len == 33);
10575 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10576 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref);
10579 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, jboolean inbound) {
10580 void* this_arg_ptr = untag_ptr(this_arg);
10581 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10582 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10583 LDKPublicKey their_node_id_ref;
10584 CHECK(their_node_id->arr_len == 33);
10585 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10587 msg_conv.inner = untag_ptr(msg);
10588 msg_conv.is_owned = ptr_is_owned(msg);
10589 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10590 msg_conv.is_owned = false;
10591 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
10592 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv, inbound);
10593 return tag_ptr(ret_conv, true);
10596 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) {
10597 void* this_arg_ptr = untag_ptr(this_arg);
10598 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10599 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10600 LDKPublicKey their_node_id_ref;
10601 CHECK(their_node_id->arr_len == 33);
10602 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10603 LDKChannelReestablish msg_conv;
10604 msg_conv.inner = untag_ptr(msg);
10605 msg_conv.is_owned = ptr_is_owned(msg);
10606 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10607 msg_conv.is_owned = false;
10608 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10611 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) {
10612 void* this_arg_ptr = untag_ptr(this_arg);
10613 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10614 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10615 LDKPublicKey their_node_id_ref;
10616 CHECK(their_node_id->arr_len == 33);
10617 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10618 LDKChannelUpdate msg_conv;
10619 msg_conv.inner = untag_ptr(msg);
10620 msg_conv.is_owned = ptr_is_owned(msg);
10621 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10622 msg_conv.is_owned = false;
10623 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10626 void __attribute__((export_name("TS_ChannelMessageHandler_handle_error"))) TS_ChannelMessageHandler_handle_error(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10627 void* this_arg_ptr = untag_ptr(this_arg);
10628 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10629 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10630 LDKPublicKey their_node_id_ref;
10631 CHECK(their_node_id->arr_len == 33);
10632 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10633 LDKErrorMessage msg_conv;
10634 msg_conv.inner = untag_ptr(msg);
10635 msg_conv.is_owned = ptr_is_owned(msg);
10636 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10637 msg_conv.is_owned = false;
10638 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10641 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_node_features"))) TS_ChannelMessageHandler_provided_node_features(uint64_t this_arg) {
10642 void* this_arg_ptr = untag_ptr(this_arg);
10643 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10644 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10645 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
10646 uint64_t ret_ref = 0;
10647 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10648 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10652 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_init_features"))) TS_ChannelMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
10653 void* this_arg_ptr = untag_ptr(this_arg);
10654 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10655 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10656 LDKPublicKey their_node_id_ref;
10657 CHECK(their_node_id->arr_len == 33);
10658 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10659 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
10660 uint64_t ret_ref = 0;
10661 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10662 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10666 typedef struct LDKRoutingMessageHandler_JCalls {
10667 atomic_size_t refcnt;
10668 uint32_t instance_ptr;
10669 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
10670 } LDKRoutingMessageHandler_JCalls;
10671 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
10672 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10673 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10677 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
10678 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10679 LDKNodeAnnouncement msg_var = *msg;
10680 uint64_t msg_ref = 0;
10681 msg_var = NodeAnnouncement_clone(&msg_var);
10682 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10683 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10684 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 88, msg_ref, 0, 0, 0, 0, 0);
10685 void* ret_ptr = untag_ptr(ret);
10686 CHECK_ACCESS(ret_ptr);
10687 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10688 FREE(untag_ptr(ret));
10691 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
10692 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10693 LDKChannelAnnouncement msg_var = *msg;
10694 uint64_t msg_ref = 0;
10695 msg_var = ChannelAnnouncement_clone(&msg_var);
10696 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10697 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10698 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 89, msg_ref, 0, 0, 0, 0, 0);
10699 void* ret_ptr = untag_ptr(ret);
10700 CHECK_ACCESS(ret_ptr);
10701 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10702 FREE(untag_ptr(ret));
10705 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
10706 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10707 LDKChannelUpdate msg_var = *msg;
10708 uint64_t msg_ref = 0;
10709 msg_var = ChannelUpdate_clone(&msg_var);
10710 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10711 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10712 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 90, msg_ref, 0, 0, 0, 0, 0);
10713 void* ret_ptr = untag_ptr(ret);
10714 CHECK_ACCESS(ret_ptr);
10715 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10716 FREE(untag_ptr(ret));
10719 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point) {
10720 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10721 int64_t starting_point_conv = starting_point;
10722 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 91, starting_point_conv, 0, 0, 0, 0, 0);
10723 void* ret_ptr = untag_ptr(ret);
10724 CHECK_ACCESS(ret_ptr);
10725 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(ret_ptr);
10726 FREE(untag_ptr(ret));
10729 LDKNodeAnnouncement get_next_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKNodeId starting_point) {
10730 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10731 LDKNodeId starting_point_var = starting_point;
10732 uint64_t starting_point_ref = 0;
10733 CHECK_INNER_FIELD_ACCESS_OR_NULL(starting_point_var);
10734 starting_point_ref = tag_ptr(starting_point_var.inner, starting_point_var.is_owned);
10735 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 92, starting_point_ref, 0, 0, 0, 0, 0);
10736 LDKNodeAnnouncement ret_conv;
10737 ret_conv.inner = untag_ptr(ret);
10738 ret_conv.is_owned = ptr_is_owned(ret);
10739 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10742 LDKCResult_NoneNoneZ peer_connected_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init, bool inbound) {
10743 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10744 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10745 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10746 LDKInit init_var = *init;
10747 uint64_t init_ref = 0;
10748 init_var = Init_clone(&init_var);
10749 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
10750 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
10751 jboolean inbound_conv = inbound;
10752 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 93, (uint32_t)their_node_id_arr, init_ref, inbound_conv, 0, 0, 0);
10753 void* ret_ptr = untag_ptr(ret);
10754 CHECK_ACCESS(ret_ptr);
10755 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
10756 FREE(untag_ptr(ret));
10759 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
10760 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10761 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10762 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10763 LDKReplyChannelRange msg_var = msg;
10764 uint64_t msg_ref = 0;
10765 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10766 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10767 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 94, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10768 void* ret_ptr = untag_ptr(ret);
10769 CHECK_ACCESS(ret_ptr);
10770 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10771 FREE(untag_ptr(ret));
10774 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
10775 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10776 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10777 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10778 LDKReplyShortChannelIdsEnd msg_var = msg;
10779 uint64_t msg_ref = 0;
10780 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10781 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10782 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 95, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10783 void* ret_ptr = untag_ptr(ret);
10784 CHECK_ACCESS(ret_ptr);
10785 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10786 FREE(untag_ptr(ret));
10789 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
10790 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10791 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10792 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10793 LDKQueryChannelRange msg_var = msg;
10794 uint64_t msg_ref = 0;
10795 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10796 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10797 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 96, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10798 void* ret_ptr = untag_ptr(ret);
10799 CHECK_ACCESS(ret_ptr);
10800 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10801 FREE(untag_ptr(ret));
10804 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
10805 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10806 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10807 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10808 LDKQueryShortChannelIds msg_var = msg;
10809 uint64_t msg_ref = 0;
10810 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10811 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10812 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 97, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10813 void* ret_ptr = untag_ptr(ret);
10814 CHECK_ACCESS(ret_ptr);
10815 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10816 FREE(untag_ptr(ret));
10819 bool processing_queue_high_LDKRoutingMessageHandler_jcall(const void* this_arg) {
10820 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10821 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 98, 0, 0, 0, 0, 0, 0);
10823 LDKNodeFeatures provided_node_features_LDKRoutingMessageHandler_jcall(const void* this_arg) {
10824 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10825 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 99, 0, 0, 0, 0, 0, 0);
10826 LDKNodeFeatures ret_conv;
10827 ret_conv.inner = untag_ptr(ret);
10828 ret_conv.is_owned = ptr_is_owned(ret);
10829 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10832 LDKInitFeatures provided_init_features_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10833 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10834 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10835 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10836 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 100, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10837 LDKInitFeatures ret_conv;
10838 ret_conv.inner = untag_ptr(ret);
10839 ret_conv.is_owned = ptr_is_owned(ret);
10840 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10843 static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
10844 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) new_obj->this_arg;
10845 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10846 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
10848 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
10849 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
10850 atomic_init(&calls->refcnt, 1);
10851 calls->instance_ptr = o;
10853 LDKRoutingMessageHandler ret = {
10854 .this_arg = (void*) calls,
10855 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
10856 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
10857 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
10858 .get_next_channel_announcement = get_next_channel_announcement_LDKRoutingMessageHandler_jcall,
10859 .get_next_node_announcement = get_next_node_announcement_LDKRoutingMessageHandler_jcall,
10860 .peer_connected = peer_connected_LDKRoutingMessageHandler_jcall,
10861 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
10862 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
10863 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
10864 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
10865 .processing_queue_high = processing_queue_high_LDKRoutingMessageHandler_jcall,
10866 .provided_node_features = provided_node_features_LDKRoutingMessageHandler_jcall,
10867 .provided_init_features = provided_init_features_LDKRoutingMessageHandler_jcall,
10868 .free = LDKRoutingMessageHandler_JCalls_free,
10869 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
10871 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
10874 uint64_t __attribute__((export_name("TS_LDKRoutingMessageHandler_new"))) TS_LDKRoutingMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
10875 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
10876 *res_ptr = LDKRoutingMessageHandler_init(o, MessageSendEventsProvider);
10877 return tag_ptr(res_ptr, true);
10879 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_node_announcement"))) TS_RoutingMessageHandler_handle_node_announcement(uint64_t this_arg, uint64_t msg) {
10880 void* this_arg_ptr = untag_ptr(this_arg);
10881 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10882 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10883 LDKNodeAnnouncement msg_conv;
10884 msg_conv.inner = untag_ptr(msg);
10885 msg_conv.is_owned = ptr_is_owned(msg);
10886 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10887 msg_conv.is_owned = false;
10888 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10889 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
10890 return tag_ptr(ret_conv, true);
10893 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_announcement"))) TS_RoutingMessageHandler_handle_channel_announcement(uint64_t this_arg, uint64_t msg) {
10894 void* this_arg_ptr = untag_ptr(this_arg);
10895 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10896 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10897 LDKChannelAnnouncement msg_conv;
10898 msg_conv.inner = untag_ptr(msg);
10899 msg_conv.is_owned = ptr_is_owned(msg);
10900 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10901 msg_conv.is_owned = false;
10902 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10903 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
10904 return tag_ptr(ret_conv, true);
10907 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_update"))) TS_RoutingMessageHandler_handle_channel_update(uint64_t this_arg, uint64_t msg) {
10908 void* this_arg_ptr = untag_ptr(this_arg);
10909 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10910 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10911 LDKChannelUpdate msg_conv;
10912 msg_conv.inner = untag_ptr(msg);
10913 msg_conv.is_owned = ptr_is_owned(msg);
10914 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10915 msg_conv.is_owned = false;
10916 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10917 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
10918 return tag_ptr(ret_conv, true);
10921 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) {
10922 void* this_arg_ptr = untag_ptr(this_arg);
10923 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10924 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10925 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
10926 *ret_copy = (this_arg_conv->get_next_channel_announcement)(this_arg_conv->this_arg, starting_point);
10927 uint64_t ret_ref = tag_ptr(ret_copy, true);
10931 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_get_next_node_announcement"))) TS_RoutingMessageHandler_get_next_node_announcement(uint64_t this_arg, uint64_t starting_point) {
10932 void* this_arg_ptr = untag_ptr(this_arg);
10933 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10934 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10935 LDKNodeId starting_point_conv;
10936 starting_point_conv.inner = untag_ptr(starting_point);
10937 starting_point_conv.is_owned = ptr_is_owned(starting_point);
10938 CHECK_INNER_FIELD_ACCESS_OR_NULL(starting_point_conv);
10939 starting_point_conv = NodeId_clone(&starting_point_conv);
10940 LDKNodeAnnouncement ret_var = (this_arg_conv->get_next_node_announcement)(this_arg_conv->this_arg, starting_point_conv);
10941 uint64_t ret_ref = 0;
10942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10943 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10947 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, jboolean inbound) {
10948 void* this_arg_ptr = untag_ptr(this_arg);
10949 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10950 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10951 LDKPublicKey their_node_id_ref;
10952 CHECK(their_node_id->arr_len == 33);
10953 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10955 init_conv.inner = untag_ptr(init);
10956 init_conv.is_owned = ptr_is_owned(init);
10957 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
10958 init_conv.is_owned = false;
10959 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
10960 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv, inbound);
10961 return tag_ptr(ret_conv, true);
10964 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) {
10965 void* this_arg_ptr = untag_ptr(this_arg);
10966 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10967 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10968 LDKPublicKey their_node_id_ref;
10969 CHECK(their_node_id->arr_len == 33);
10970 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10971 LDKReplyChannelRange msg_conv;
10972 msg_conv.inner = untag_ptr(msg);
10973 msg_conv.is_owned = ptr_is_owned(msg);
10974 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10975 msg_conv = ReplyChannelRange_clone(&msg_conv);
10976 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10977 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10978 return tag_ptr(ret_conv, true);
10981 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) {
10982 void* this_arg_ptr = untag_ptr(this_arg);
10983 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10984 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10985 LDKPublicKey their_node_id_ref;
10986 CHECK(their_node_id->arr_len == 33);
10987 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10988 LDKReplyShortChannelIdsEnd msg_conv;
10989 msg_conv.inner = untag_ptr(msg);
10990 msg_conv.is_owned = ptr_is_owned(msg);
10991 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10992 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
10993 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10994 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10995 return tag_ptr(ret_conv, true);
10998 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) {
10999 void* this_arg_ptr = untag_ptr(this_arg);
11000 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11001 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11002 LDKPublicKey their_node_id_ref;
11003 CHECK(their_node_id->arr_len == 33);
11004 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11005 LDKQueryChannelRange msg_conv;
11006 msg_conv.inner = untag_ptr(msg);
11007 msg_conv.is_owned = ptr_is_owned(msg);
11008 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
11009 msg_conv = QueryChannelRange_clone(&msg_conv);
11010 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11011 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
11012 return tag_ptr(ret_conv, true);
11015 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) {
11016 void* this_arg_ptr = untag_ptr(this_arg);
11017 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11018 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11019 LDKPublicKey their_node_id_ref;
11020 CHECK(their_node_id->arr_len == 33);
11021 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11022 LDKQueryShortChannelIds msg_conv;
11023 msg_conv.inner = untag_ptr(msg);
11024 msg_conv.is_owned = ptr_is_owned(msg);
11025 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
11026 msg_conv = QueryShortChannelIds_clone(&msg_conv);
11027 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11028 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
11029 return tag_ptr(ret_conv, true);
11032 jboolean __attribute__((export_name("TS_RoutingMessageHandler_processing_queue_high"))) TS_RoutingMessageHandler_processing_queue_high(uint64_t this_arg) {
11033 void* this_arg_ptr = untag_ptr(this_arg);
11034 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11035 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11036 jboolean ret_conv = (this_arg_conv->processing_queue_high)(this_arg_conv->this_arg);
11040 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_node_features"))) TS_RoutingMessageHandler_provided_node_features(uint64_t this_arg) {
11041 void* this_arg_ptr = untag_ptr(this_arg);
11042 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11043 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11044 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
11045 uint64_t ret_ref = 0;
11046 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11047 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11051 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_init_features"))) TS_RoutingMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
11052 void* this_arg_ptr = untag_ptr(this_arg);
11053 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11054 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11055 LDKPublicKey their_node_id_ref;
11056 CHECK(their_node_id->arr_len == 33);
11057 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11058 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
11059 uint64_t ret_ref = 0;
11060 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11061 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11065 typedef struct LDKOnionMessageProvider_JCalls {
11066 atomic_size_t refcnt;
11067 uint32_t instance_ptr;
11068 } LDKOnionMessageProvider_JCalls;
11069 static void LDKOnionMessageProvider_JCalls_free(void* this_arg) {
11070 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
11071 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11075 LDKOnionMessage next_onion_message_for_peer_LDKOnionMessageProvider_jcall(const void* this_arg, LDKPublicKey peer_node_id) {
11076 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
11077 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
11078 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
11079 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 101, (uint32_t)peer_node_id_arr, 0, 0, 0, 0, 0);
11080 LDKOnionMessage ret_conv;
11081 ret_conv.inner = untag_ptr(ret);
11082 ret_conv.is_owned = ptr_is_owned(ret);
11083 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11086 static void LDKOnionMessageProvider_JCalls_cloned(LDKOnionMessageProvider* new_obj) {
11087 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) new_obj->this_arg;
11088 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11090 static inline LDKOnionMessageProvider LDKOnionMessageProvider_init (JSValue o) {
11091 LDKOnionMessageProvider_JCalls *calls = MALLOC(sizeof(LDKOnionMessageProvider_JCalls), "LDKOnionMessageProvider_JCalls");
11092 atomic_init(&calls->refcnt, 1);
11093 calls->instance_ptr = o;
11095 LDKOnionMessageProvider ret = {
11096 .this_arg = (void*) calls,
11097 .next_onion_message_for_peer = next_onion_message_for_peer_LDKOnionMessageProvider_jcall,
11098 .free = LDKOnionMessageProvider_JCalls_free,
11102 uint64_t __attribute__((export_name("TS_LDKOnionMessageProvider_new"))) TS_LDKOnionMessageProvider_new(JSValue o) {
11103 LDKOnionMessageProvider *res_ptr = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
11104 *res_ptr = LDKOnionMessageProvider_init(o);
11105 return tag_ptr(res_ptr, true);
11107 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) {
11108 void* this_arg_ptr = untag_ptr(this_arg);
11109 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11110 LDKOnionMessageProvider* this_arg_conv = (LDKOnionMessageProvider*)this_arg_ptr;
11111 LDKPublicKey peer_node_id_ref;
11112 CHECK(peer_node_id->arr_len == 33);
11113 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
11114 LDKOnionMessage ret_var = (this_arg_conv->next_onion_message_for_peer)(this_arg_conv->this_arg, peer_node_id_ref);
11115 uint64_t ret_ref = 0;
11116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11117 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11121 typedef struct LDKOnionMessageHandler_JCalls {
11122 atomic_size_t refcnt;
11123 uint32_t instance_ptr;
11124 LDKOnionMessageProvider_JCalls* OnionMessageProvider;
11125 } LDKOnionMessageHandler_JCalls;
11126 static void LDKOnionMessageHandler_JCalls_free(void* this_arg) {
11127 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11128 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11132 void handle_onion_message_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey peer_node_id, const LDKOnionMessage * msg) {
11133 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11134 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
11135 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
11136 LDKOnionMessage msg_var = *msg;
11137 uint64_t msg_ref = 0;
11138 msg_var = OnionMessage_clone(&msg_var);
11139 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
11140 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
11141 js_invoke_function_ubuuuu(j_calls->instance_ptr, 102, (uint32_t)peer_node_id_arr, msg_ref, 0, 0, 0, 0);
11143 LDKCResult_NoneNoneZ peer_connected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init, bool inbound) {
11144 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11145 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
11146 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
11147 LDKInit init_var = *init;
11148 uint64_t init_ref = 0;
11149 init_var = Init_clone(&init_var);
11150 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
11151 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
11152 jboolean inbound_conv = inbound;
11153 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 103, (uint32_t)their_node_id_arr, init_ref, inbound_conv, 0, 0, 0);
11154 void* ret_ptr = untag_ptr(ret);
11155 CHECK_ACCESS(ret_ptr);
11156 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
11157 FREE(untag_ptr(ret));
11160 void peer_disconnected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
11161 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11162 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
11163 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
11164 js_invoke_function_uuuuuu(j_calls->instance_ptr, 104, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
11166 LDKNodeFeatures provided_node_features_LDKOnionMessageHandler_jcall(const void* this_arg) {
11167 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11168 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 105, 0, 0, 0, 0, 0, 0);
11169 LDKNodeFeatures ret_conv;
11170 ret_conv.inner = untag_ptr(ret);
11171 ret_conv.is_owned = ptr_is_owned(ret);
11172 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11175 LDKInitFeatures provided_init_features_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
11176 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11177 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
11178 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
11179 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 106, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
11180 LDKInitFeatures ret_conv;
11181 ret_conv.inner = untag_ptr(ret);
11182 ret_conv.is_owned = ptr_is_owned(ret);
11183 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11186 static void LDKOnionMessageHandler_JCalls_cloned(LDKOnionMessageHandler* new_obj) {
11187 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) new_obj->this_arg;
11188 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11189 atomic_fetch_add_explicit(&j_calls->OnionMessageProvider->refcnt, 1, memory_order_release);
11191 static inline LDKOnionMessageHandler LDKOnionMessageHandler_init (JSValue o, JSValue OnionMessageProvider) {
11192 LDKOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKOnionMessageHandler_JCalls), "LDKOnionMessageHandler_JCalls");
11193 atomic_init(&calls->refcnt, 1);
11194 calls->instance_ptr = o;
11196 LDKOnionMessageHandler ret = {
11197 .this_arg = (void*) calls,
11198 .handle_onion_message = handle_onion_message_LDKOnionMessageHandler_jcall,
11199 .peer_connected = peer_connected_LDKOnionMessageHandler_jcall,
11200 .peer_disconnected = peer_disconnected_LDKOnionMessageHandler_jcall,
11201 .provided_node_features = provided_node_features_LDKOnionMessageHandler_jcall,
11202 .provided_init_features = provided_init_features_LDKOnionMessageHandler_jcall,
11203 .free = LDKOnionMessageHandler_JCalls_free,
11204 .OnionMessageProvider = LDKOnionMessageProvider_init(OnionMessageProvider),
11206 calls->OnionMessageProvider = ret.OnionMessageProvider.this_arg;
11209 uint64_t __attribute__((export_name("TS_LDKOnionMessageHandler_new"))) TS_LDKOnionMessageHandler_new(JSValue o, JSValue OnionMessageProvider) {
11210 LDKOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
11211 *res_ptr = LDKOnionMessageHandler_init(o, OnionMessageProvider);
11212 return tag_ptr(res_ptr, true);
11214 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) {
11215 void* this_arg_ptr = untag_ptr(this_arg);
11216 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11217 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11218 LDKPublicKey peer_node_id_ref;
11219 CHECK(peer_node_id->arr_len == 33);
11220 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
11221 LDKOnionMessage msg_conv;
11222 msg_conv.inner = untag_ptr(msg);
11223 msg_conv.is_owned = ptr_is_owned(msg);
11224 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
11225 msg_conv.is_owned = false;
11226 (this_arg_conv->handle_onion_message)(this_arg_conv->this_arg, peer_node_id_ref, &msg_conv);
11229 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, jboolean inbound) {
11230 void* this_arg_ptr = untag_ptr(this_arg);
11231 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11232 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11233 LDKPublicKey their_node_id_ref;
11234 CHECK(their_node_id->arr_len == 33);
11235 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11237 init_conv.inner = untag_ptr(init);
11238 init_conv.is_owned = ptr_is_owned(init);
11239 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
11240 init_conv.is_owned = false;
11241 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11242 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv, inbound);
11243 return tag_ptr(ret_conv, true);
11246 void __attribute__((export_name("TS_OnionMessageHandler_peer_disconnected"))) TS_OnionMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id) {
11247 void* this_arg_ptr = untag_ptr(this_arg);
11248 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11249 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11250 LDKPublicKey their_node_id_ref;
11251 CHECK(their_node_id->arr_len == 33);
11252 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11253 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref);
11256 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_node_features"))) TS_OnionMessageHandler_provided_node_features(uint64_t this_arg) {
11257 void* this_arg_ptr = untag_ptr(this_arg);
11258 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11259 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11260 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
11261 uint64_t ret_ref = 0;
11262 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11263 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11267 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_init_features"))) TS_OnionMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
11268 void* this_arg_ptr = untag_ptr(this_arg);
11269 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11270 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11271 LDKPublicKey their_node_id_ref;
11272 CHECK(their_node_id->arr_len == 33);
11273 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11274 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
11275 uint64_t ret_ref = 0;
11276 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11277 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11281 typedef struct LDKCustomMessageReader_JCalls {
11282 atomic_size_t refcnt;
11283 uint32_t instance_ptr;
11284 } LDKCustomMessageReader_JCalls;
11285 static void LDKCustomMessageReader_JCalls_free(void* this_arg) {
11286 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
11287 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11291 LDKCResult_COption_TypeZDecodeErrorZ read_LDKCustomMessageReader_jcall(const void* this_arg, uint16_t message_type, LDKu8slice buffer) {
11292 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
11293 int16_t message_type_conv = message_type;
11294 LDKu8slice buffer_var = buffer;
11295 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
11296 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
11297 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 107, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
11298 void* ret_ptr = untag_ptr(ret);
11299 CHECK_ACCESS(ret_ptr);
11300 LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
11301 FREE(untag_ptr(ret));
11304 static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
11305 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) new_obj->this_arg;
11306 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11308 static inline LDKCustomMessageReader LDKCustomMessageReader_init (JSValue o) {
11309 LDKCustomMessageReader_JCalls *calls = MALLOC(sizeof(LDKCustomMessageReader_JCalls), "LDKCustomMessageReader_JCalls");
11310 atomic_init(&calls->refcnt, 1);
11311 calls->instance_ptr = o;
11313 LDKCustomMessageReader ret = {
11314 .this_arg = (void*) calls,
11315 .read = read_LDKCustomMessageReader_jcall,
11316 .free = LDKCustomMessageReader_JCalls_free,
11320 uint64_t __attribute__((export_name("TS_LDKCustomMessageReader_new"))) TS_LDKCustomMessageReader_new(JSValue o) {
11321 LDKCustomMessageReader *res_ptr = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
11322 *res_ptr = LDKCustomMessageReader_init(o);
11323 return tag_ptr(res_ptr, true);
11325 uint64_t __attribute__((export_name("TS_CustomMessageReader_read"))) TS_CustomMessageReader_read(uint64_t this_arg, int16_t message_type, int8_tArray buffer) {
11326 void* this_arg_ptr = untag_ptr(this_arg);
11327 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11328 LDKCustomMessageReader* this_arg_conv = (LDKCustomMessageReader*)this_arg_ptr;
11329 LDKu8slice buffer_ref;
11330 buffer_ref.datalen = buffer->arr_len;
11331 buffer_ref.data = buffer->elems;
11332 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
11333 *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, message_type, buffer_ref);
11335 return tag_ptr(ret_conv, true);
11338 typedef struct LDKCustomMessageHandler_JCalls {
11339 atomic_size_t refcnt;
11340 uint32_t instance_ptr;
11341 LDKCustomMessageReader_JCalls* CustomMessageReader;
11342 } LDKCustomMessageHandler_JCalls;
11343 static void LDKCustomMessageHandler_JCalls_free(void* this_arg) {
11344 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
11345 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11349 LDKCResult_NoneLightningErrorZ handle_custom_message_LDKCustomMessageHandler_jcall(const void* this_arg, LDKType msg, LDKPublicKey sender_node_id) {
11350 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
11351 LDKType* msg_ret = MALLOC(sizeof(LDKType), "LDKType");
11353 int8_tArray sender_node_id_arr = init_int8_tArray(33, __LINE__);
11354 memcpy(sender_node_id_arr->elems, sender_node_id.compressed_form, 33);
11355 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 108, tag_ptr(msg_ret, true), (uint32_t)sender_node_id_arr, 0, 0, 0, 0);
11356 void* ret_ptr = untag_ptr(ret);
11357 CHECK_ACCESS(ret_ptr);
11358 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
11359 FREE(untag_ptr(ret));
11362 LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
11363 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
11364 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 109, 0, 0, 0, 0, 0, 0);
11365 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_constr;
11366 ret_constr.datalen = ret->arr_len;
11367 if (ret_constr.datalen > 0)
11368 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
11370 ret_constr.data = NULL;
11371 uint64_t* ret_vals = ret->elems;
11372 for (size_t z = 0; z < ret_constr.datalen; z++) {
11373 uint64_t ret_conv_25 = ret_vals[z];
11374 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
11375 CHECK_ACCESS(ret_conv_25_ptr);
11376 LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
11377 FREE(untag_ptr(ret_conv_25));
11378 ret_constr.data[z] = ret_conv_25_conv;
11383 static void LDKCustomMessageHandler_JCalls_cloned(LDKCustomMessageHandler* new_obj) {
11384 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) new_obj->this_arg;
11385 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11386 atomic_fetch_add_explicit(&j_calls->CustomMessageReader->refcnt, 1, memory_order_release);
11388 static inline LDKCustomMessageHandler LDKCustomMessageHandler_init (JSValue o, JSValue CustomMessageReader) {
11389 LDKCustomMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomMessageHandler_JCalls), "LDKCustomMessageHandler_JCalls");
11390 atomic_init(&calls->refcnt, 1);
11391 calls->instance_ptr = o;
11393 LDKCustomMessageHandler ret = {
11394 .this_arg = (void*) calls,
11395 .handle_custom_message = handle_custom_message_LDKCustomMessageHandler_jcall,
11396 .get_and_clear_pending_msg = get_and_clear_pending_msg_LDKCustomMessageHandler_jcall,
11397 .free = LDKCustomMessageHandler_JCalls_free,
11398 .CustomMessageReader = LDKCustomMessageReader_init(CustomMessageReader),
11400 calls->CustomMessageReader = ret.CustomMessageReader.this_arg;
11403 uint64_t __attribute__((export_name("TS_LDKCustomMessageHandler_new"))) TS_LDKCustomMessageHandler_new(JSValue o, JSValue CustomMessageReader) {
11404 LDKCustomMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
11405 *res_ptr = LDKCustomMessageHandler_init(o, CustomMessageReader);
11406 return tag_ptr(res_ptr, true);
11408 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) {
11409 void* this_arg_ptr = untag_ptr(this_arg);
11410 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11411 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
11412 void* msg_ptr = untag_ptr(msg);
11413 CHECK_ACCESS(msg_ptr);
11414 LDKType msg_conv = *(LDKType*)(msg_ptr);
11415 if (msg_conv.free == LDKType_JCalls_free) {
11416 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11417 LDKType_JCalls_cloned(&msg_conv);
11419 LDKPublicKey sender_node_id_ref;
11420 CHECK(sender_node_id->arr_len == 33);
11421 memcpy(sender_node_id_ref.compressed_form, sender_node_id->elems, 33); FREE(sender_node_id);
11422 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11423 *ret_conv = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv, sender_node_id_ref);
11424 return tag_ptr(ret_conv, true);
11427 uint64_tArray __attribute__((export_name("TS_CustomMessageHandler_get_and_clear_pending_msg"))) TS_CustomMessageHandler_get_and_clear_pending_msg(uint64_t this_arg) {
11428 void* this_arg_ptr = untag_ptr(this_arg);
11429 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11430 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
11431 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_var = (this_arg_conv->get_and_clear_pending_msg)(this_arg_conv->this_arg);
11432 uint64_tArray ret_arr = NULL;
11433 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
11434 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
11435 for (size_t z = 0; z < ret_var.datalen; z++) {
11436 LDKC2Tuple_PublicKeyTypeZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
11437 *ret_conv_25_conv = ret_var.data[z];
11438 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
11441 FREE(ret_var.data);
11445 typedef struct LDKCustomOnionMessageHandler_JCalls {
11446 atomic_size_t refcnt;
11447 uint32_t instance_ptr;
11448 } LDKCustomOnionMessageHandler_JCalls;
11449 static void LDKCustomOnionMessageHandler_JCalls_free(void* this_arg) {
11450 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
11451 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11455 void handle_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, LDKCustomOnionMessageContents msg) {
11456 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
11457 LDKCustomOnionMessageContents* msg_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
11459 js_invoke_function_buuuuu(j_calls->instance_ptr, 110, tag_ptr(msg_ret, true), 0, 0, 0, 0, 0);
11461 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, uint64_t message_type, LDKu8slice buffer) {
11462 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
11463 int64_t message_type_conv = message_type;
11464 LDKu8slice buffer_var = buffer;
11465 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
11466 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
11467 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 111, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
11468 void* ret_ptr = untag_ptr(ret);
11469 CHECK_ACCESS(ret_ptr);
11470 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(ret_ptr);
11471 FREE(untag_ptr(ret));
11474 static void LDKCustomOnionMessageHandler_JCalls_cloned(LDKCustomOnionMessageHandler* new_obj) {
11475 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) new_obj->this_arg;
11476 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11478 static inline LDKCustomOnionMessageHandler LDKCustomOnionMessageHandler_init (JSValue o) {
11479 LDKCustomOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageHandler_JCalls), "LDKCustomOnionMessageHandler_JCalls");
11480 atomic_init(&calls->refcnt, 1);
11481 calls->instance_ptr = o;
11483 LDKCustomOnionMessageHandler ret = {
11484 .this_arg = (void*) calls,
11485 .handle_custom_message = handle_custom_message_LDKCustomOnionMessageHandler_jcall,
11486 .read_custom_message = read_custom_message_LDKCustomOnionMessageHandler_jcall,
11487 .free = LDKCustomOnionMessageHandler_JCalls_free,
11491 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageHandler_new"))) TS_LDKCustomOnionMessageHandler_new(JSValue o) {
11492 LDKCustomOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
11493 *res_ptr = LDKCustomOnionMessageHandler_init(o);
11494 return tag_ptr(res_ptr, true);
11496 void __attribute__((export_name("TS_CustomOnionMessageHandler_handle_custom_message"))) TS_CustomOnionMessageHandler_handle_custom_message(uint64_t this_arg, uint64_t msg) {
11497 void* this_arg_ptr = untag_ptr(this_arg);
11498 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11499 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
11500 void* msg_ptr = untag_ptr(msg);
11501 CHECK_ACCESS(msg_ptr);
11502 LDKCustomOnionMessageContents msg_conv = *(LDKCustomOnionMessageContents*)(msg_ptr);
11503 if (msg_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
11504 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11505 LDKCustomOnionMessageContents_JCalls_cloned(&msg_conv);
11507 (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv);
11510 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) {
11511 void* this_arg_ptr = untag_ptr(this_arg);
11512 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11513 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
11514 LDKu8slice buffer_ref;
11515 buffer_ref.datalen = buffer->arr_len;
11516 buffer_ref.data = buffer->elems;
11517 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
11518 *ret_conv = (this_arg_conv->read_custom_message)(this_arg_conv->this_arg, message_type, buffer_ref);
11520 return tag_ptr(ret_conv, true);
11523 typedef struct LDKSocketDescriptor_JCalls {
11524 atomic_size_t refcnt;
11525 uint32_t instance_ptr;
11526 } LDKSocketDescriptor_JCalls;
11527 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
11528 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11529 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11533 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
11534 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11535 LDKu8slice data_var = data;
11536 int8_tArray data_arr = init_int8_tArray(data_var.datalen, __LINE__);
11537 memcpy(data_arr->elems, data_var.data, data_var.datalen);
11538 jboolean resume_read_conv = resume_read;
11539 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 112, (uint32_t)data_arr, resume_read_conv, 0, 0, 0, 0);
11541 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
11542 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11543 js_invoke_function_uuuuuu(j_calls->instance_ptr, 113, 0, 0, 0, 0, 0, 0);
11545 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
11546 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11547 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
11548 *other_arg_clone = SocketDescriptor_clone(other_arg);
11549 return js_invoke_function_buuuuu(j_calls->instance_ptr, 114, tag_ptr(other_arg_clone, true), 0, 0, 0, 0, 0);
11551 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
11552 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11553 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 115, 0, 0, 0, 0, 0, 0);
11555 static void LDKSocketDescriptor_JCalls_cloned(LDKSocketDescriptor* new_obj) {
11556 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) new_obj->this_arg;
11557 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11559 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JSValue o) {
11560 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
11561 atomic_init(&calls->refcnt, 1);
11562 calls->instance_ptr = o;
11564 LDKSocketDescriptor ret = {
11565 .this_arg = (void*) calls,
11566 .send_data = send_data_LDKSocketDescriptor_jcall,
11567 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
11568 .eq = eq_LDKSocketDescriptor_jcall,
11569 .hash = hash_LDKSocketDescriptor_jcall,
11570 .cloned = LDKSocketDescriptor_JCalls_cloned,
11571 .free = LDKSocketDescriptor_JCalls_free,
11575 uint64_t __attribute__((export_name("TS_LDKSocketDescriptor_new"))) TS_LDKSocketDescriptor_new(JSValue o) {
11576 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
11577 *res_ptr = LDKSocketDescriptor_init(o);
11578 return tag_ptr(res_ptr, true);
11580 uint32_t __attribute__((export_name("TS_SocketDescriptor_send_data"))) TS_SocketDescriptor_send_data(uint64_t this_arg, int8_tArray data, jboolean resume_read) {
11581 void* this_arg_ptr = untag_ptr(this_arg);
11582 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11583 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
11584 LDKu8slice data_ref;
11585 data_ref.datalen = data->arr_len;
11586 data_ref.data = data->elems;
11587 uint32_t ret_conv = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
11592 void __attribute__((export_name("TS_SocketDescriptor_disconnect_socket"))) TS_SocketDescriptor_disconnect_socket(uint64_t this_arg) {
11593 void* this_arg_ptr = untag_ptr(this_arg);
11594 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11595 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
11596 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
11599 int64_t __attribute__((export_name("TS_SocketDescriptor_hash"))) TS_SocketDescriptor_hash(uint64_t this_arg) {
11600 void* this_arg_ptr = untag_ptr(this_arg);
11601 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11602 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
11603 int64_t ret_conv = (this_arg_conv->hash)(this_arg_conv->this_arg);
11607 uint32_t __attribute__((export_name("TS_LDKEffectiveCapacity_ty_from_ptr"))) TS_LDKEffectiveCapacity_ty_from_ptr(uint64_t ptr) {
11608 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11610 case LDKEffectiveCapacity_ExactLiquidity: return 0;
11611 case LDKEffectiveCapacity_MaximumHTLC: return 1;
11612 case LDKEffectiveCapacity_Total: return 2;
11613 case LDKEffectiveCapacity_Infinite: return 3;
11614 case LDKEffectiveCapacity_Unknown: return 4;
11618 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat"))) TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(uint64_t ptr) {
11619 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11620 assert(obj->tag == LDKEffectiveCapacity_ExactLiquidity);
11621 int64_t liquidity_msat_conv = obj->exact_liquidity.liquidity_msat;
11622 return liquidity_msat_conv;
11624 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat"))) TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(uint64_t ptr) {
11625 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11626 assert(obj->tag == LDKEffectiveCapacity_MaximumHTLC);
11627 int64_t amount_msat_conv = obj->maximum_htlc.amount_msat;
11628 return amount_msat_conv;
11630 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_capacity_msat"))) TS_LDKEffectiveCapacity_Total_get_capacity_msat(uint64_t ptr) {
11631 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11632 assert(obj->tag == LDKEffectiveCapacity_Total);
11633 int64_t capacity_msat_conv = obj->total.capacity_msat;
11634 return capacity_msat_conv;
11636 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat"))) TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(uint64_t ptr) {
11637 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11638 assert(obj->tag == LDKEffectiveCapacity_Total);
11639 int64_t htlc_maximum_msat_conv = obj->total.htlc_maximum_msat;
11640 return htlc_maximum_msat_conv;
11642 uint32_t __attribute__((export_name("TS_LDKHints_ty_from_ptr"))) TS_LDKHints_ty_from_ptr(uint64_t ptr) {
11643 LDKHints *obj = (LDKHints*)untag_ptr(ptr);
11645 case LDKHints_Blinded: return 0;
11646 case LDKHints_Clear: return 1;
11650 uint64_tArray __attribute__((export_name("TS_LDKHints_Blinded_get_blinded"))) TS_LDKHints_Blinded_get_blinded(uint64_t ptr) {
11651 LDKHints *obj = (LDKHints*)untag_ptr(ptr);
11652 assert(obj->tag == LDKHints_Blinded);
11653 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_var = obj->blinded;
11654 uint64_tArray blinded_arr = NULL;
11655 blinded_arr = init_uint64_tArray(blinded_var.datalen, __LINE__);
11656 uint64_t *blinded_arr_ptr = (uint64_t*)(((uint8_t*)blinded_arr) + 8);
11657 for (size_t l = 0; l < blinded_var.datalen; l++) {
11658 LDKC2Tuple_BlindedPayInfoBlindedPathZ* blinded_conv_37_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
11659 *blinded_conv_37_conv = blinded_var.data[l];
11660 *blinded_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(blinded_conv_37_conv);
11661 blinded_arr_ptr[l] = tag_ptr(blinded_conv_37_conv, true);
11664 return blinded_arr;
11666 uint64_tArray __attribute__((export_name("TS_LDKHints_Clear_get_clear"))) TS_LDKHints_Clear_get_clear(uint64_t ptr) {
11667 LDKHints *obj = (LDKHints*)untag_ptr(ptr);
11668 assert(obj->tag == LDKHints_Clear);
11669 LDKCVec_RouteHintZ clear_var = obj->clear;
11670 uint64_tArray clear_arr = NULL;
11671 clear_arr = init_uint64_tArray(clear_var.datalen, __LINE__);
11672 uint64_t *clear_arr_ptr = (uint64_t*)(((uint8_t*)clear_arr) + 8);
11673 for (size_t l = 0; l < clear_var.datalen; l++) {
11674 LDKRouteHint clear_conv_11_var = clear_var.data[l];
11675 uint64_t clear_conv_11_ref = 0;
11676 CHECK_INNER_FIELD_ACCESS_OR_NULL(clear_conv_11_var);
11677 clear_conv_11_ref = tag_ptr(clear_conv_11_var.inner, false);
11678 clear_arr_ptr[l] = clear_conv_11_ref;
11683 uint32_t __attribute__((export_name("TS_LDKDestination_ty_from_ptr"))) TS_LDKDestination_ty_from_ptr(uint64_t ptr) {
11684 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11686 case LDKDestination_Node: return 0;
11687 case LDKDestination_BlindedPath: return 1;
11691 int8_tArray __attribute__((export_name("TS_LDKDestination_Node_get_node"))) TS_LDKDestination_Node_get_node(uint64_t ptr) {
11692 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11693 assert(obj->tag == LDKDestination_Node);
11694 int8_tArray node_arr = init_int8_tArray(33, __LINE__);
11695 memcpy(node_arr->elems, obj->node.compressed_form, 33);
11698 uint64_t __attribute__((export_name("TS_LDKDestination_BlindedPath_get_blinded_path"))) TS_LDKDestination_BlindedPath_get_blinded_path(uint64_t ptr) {
11699 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11700 assert(obj->tag == LDKDestination_BlindedPath);
11701 LDKBlindedPath blinded_path_var = obj->blinded_path;
11702 uint64_t blinded_path_ref = 0;
11703 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_path_var);
11704 blinded_path_ref = tag_ptr(blinded_path_var.inner, false);
11705 return blinded_path_ref;
11707 uint32_t __attribute__((export_name("TS_LDKOnionMessageContents_ty_from_ptr"))) TS_LDKOnionMessageContents_ty_from_ptr(uint64_t ptr) {
11708 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
11710 case LDKOnionMessageContents_Custom: return 0;
11714 uint64_t __attribute__((export_name("TS_LDKOnionMessageContents_Custom_get_custom"))) TS_LDKOnionMessageContents_Custom_get_custom(uint64_t ptr) {
11715 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
11716 assert(obj->tag == LDKOnionMessageContents_Custom);
11717 LDKCustomOnionMessageContents* custom_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
11718 *custom_ret = CustomOnionMessageContents_clone(&obj->custom);
11719 return tag_ptr(custom_ret, true);
11721 uint32_t __attribute__((export_name("TS_LDKGossipSync_ty_from_ptr"))) TS_LDKGossipSync_ty_from_ptr(uint64_t ptr) {
11722 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
11724 case LDKGossipSync_P2P: return 0;
11725 case LDKGossipSync_Rapid: return 1;
11726 case LDKGossipSync_None: return 2;
11730 uint64_t __attribute__((export_name("TS_LDKGossipSync_P2P_get_p2p"))) TS_LDKGossipSync_P2P_get_p2p(uint64_t ptr) {
11731 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
11732 assert(obj->tag == LDKGossipSync_P2P);
11733 LDKP2PGossipSync p2p_var = obj->p2p;
11734 uint64_t p2p_ref = 0;
11735 CHECK_INNER_FIELD_ACCESS_OR_NULL(p2p_var);
11736 p2p_ref = tag_ptr(p2p_var.inner, false);
11739 uint64_t __attribute__((export_name("TS_LDKGossipSync_Rapid_get_rapid"))) TS_LDKGossipSync_Rapid_get_rapid(uint64_t ptr) {
11740 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
11741 assert(obj->tag == LDKGossipSync_Rapid);
11742 LDKRapidGossipSync rapid_var = obj->rapid;
11743 uint64_t rapid_ref = 0;
11744 CHECK_INNER_FIELD_ACCESS_OR_NULL(rapid_var);
11745 rapid_ref = tag_ptr(rapid_var.inner, false);
11748 uint32_t __attribute__((export_name("TS_LDKFallback_ty_from_ptr"))) TS_LDKFallback_ty_from_ptr(uint64_t ptr) {
11749 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11751 case LDKFallback_SegWitProgram: return 0;
11752 case LDKFallback_PubKeyHash: return 1;
11753 case LDKFallback_ScriptHash: return 2;
11757 int8_t __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_version"))) TS_LDKFallback_SegWitProgram_get_version(uint64_t ptr) {
11758 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11759 assert(obj->tag == LDKFallback_SegWitProgram);
11760 uint8_t version_val = obj->seg_wit_program.version._0;
11761 return version_val;
11763 int8_tArray __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_program"))) TS_LDKFallback_SegWitProgram_get_program(uint64_t ptr) {
11764 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11765 assert(obj->tag == LDKFallback_SegWitProgram);
11766 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
11767 int8_tArray program_arr = init_int8_tArray(program_var.datalen, __LINE__);
11768 memcpy(program_arr->elems, program_var.data, program_var.datalen);
11769 return program_arr;
11771 int8_tArray __attribute__((export_name("TS_LDKFallback_PubKeyHash_get_pub_key_hash"))) TS_LDKFallback_PubKeyHash_get_pub_key_hash(uint64_t ptr) {
11772 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11773 assert(obj->tag == LDKFallback_PubKeyHash);
11774 int8_tArray pub_key_hash_arr = init_int8_tArray(20, __LINE__);
11775 memcpy(pub_key_hash_arr->elems, obj->pub_key_hash.data, 20);
11776 return pub_key_hash_arr;
11778 int8_tArray __attribute__((export_name("TS_LDKFallback_ScriptHash_get_script_hash"))) TS_LDKFallback_ScriptHash_get_script_hash(uint64_t ptr) {
11779 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11780 assert(obj->tag == LDKFallback_ScriptHash);
11781 int8_tArray script_hash_arr = init_int8_tArray(20, __LINE__);
11782 memcpy(script_hash_arr->elems, obj->script_hash.data, 20);
11783 return script_hash_arr;
11785 jstring __attribute__((export_name("TS__ldk_get_compiled_version"))) TS__ldk_get_compiled_version() {
11786 LDKStr ret_str = _ldk_get_compiled_version();
11787 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11792 jstring __attribute__((export_name("TS__ldk_c_bindings_get_compiled_version"))) TS__ldk_c_bindings_get_compiled_version() {
11793 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
11794 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11799 int8_tArray __attribute__((export_name("TS_U128_le_bytes"))) TS_U128_le_bytes(int8_tArray val) {
11801 CHECK(val->arr_len == 16);
11802 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
11803 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
11804 memcpy(ret_arr->elems, U128_le_bytes(val_ref).data, 16);
11808 int8_tArray __attribute__((export_name("TS_U128_new"))) TS_U128_new(int8_tArray le_bytes) {
11809 LDKSixteenBytes le_bytes_ref;
11810 CHECK(le_bytes->arr_len == 16);
11811 memcpy(le_bytes_ref.data, le_bytes->elems, 16); FREE(le_bytes);
11812 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
11813 memcpy(ret_arr->elems, U128_new(le_bytes_ref).le_bytes, 16);
11817 uint64_t __attribute__((export_name("TS_BigEndianScalar_new"))) TS_BigEndianScalar_new(int8_tArray big_endian_bytes) {
11818 LDKThirtyTwoBytes big_endian_bytes_ref;
11819 CHECK(big_endian_bytes->arr_len == 32);
11820 memcpy(big_endian_bytes_ref.data, big_endian_bytes->elems, 32); FREE(big_endian_bytes);
11821 LDKBigEndianScalar* ret_ref = MALLOC(sizeof(LDKBigEndianScalar), "LDKBigEndianScalar");
11822 *ret_ref = BigEndianScalar_new(big_endian_bytes_ref);
11823 return tag_ptr(ret_ref, true);
11826 static inline uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg) {
11827 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11828 *ret_copy = Bech32Error_clone(arg);
11829 uint64_t ret_ref = tag_ptr(ret_copy, true);
11832 int64_t __attribute__((export_name("TS_Bech32Error_clone_ptr"))) TS_Bech32Error_clone_ptr(uint64_t arg) {
11833 LDKBech32Error* arg_conv = (LDKBech32Error*)untag_ptr(arg);
11834 int64_t ret_conv = Bech32Error_clone_ptr(arg_conv);
11838 uint64_t __attribute__((export_name("TS_Bech32Error_clone"))) TS_Bech32Error_clone(uint64_t orig) {
11839 LDKBech32Error* orig_conv = (LDKBech32Error*)untag_ptr(orig);
11840 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11841 *ret_copy = Bech32Error_clone(orig_conv);
11842 uint64_t ret_ref = tag_ptr(ret_copy, true);
11846 void __attribute__((export_name("TS_Bech32Error_free"))) TS_Bech32Error_free(uint64_t o) {
11847 if (!ptr_is_owned(o)) return;
11848 void* o_ptr = untag_ptr(o);
11849 CHECK_ACCESS(o_ptr);
11850 LDKBech32Error o_conv = *(LDKBech32Error*)(o_ptr);
11851 FREE(untag_ptr(o));
11852 Bech32Error_free(o_conv);
11855 void __attribute__((export_name("TS_Transaction_free"))) TS_Transaction_free(int8_tArray _res) {
11856 LDKTransaction _res_ref;
11857 _res_ref.datalen = _res->arr_len;
11858 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
11859 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11860 _res_ref.data_is_owned = true;
11861 Transaction_free(_res_ref);
11864 void __attribute__((export_name("TS_Witness_free"))) TS_Witness_free(int8_tArray _res) {
11865 LDKWitness _res_ref;
11866 _res_ref.datalen = _res->arr_len;
11867 _res_ref.data = MALLOC(_res_ref.datalen, "LDKWitness Bytes");
11868 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11869 _res_ref.data_is_owned = true;
11870 Witness_free(_res_ref);
11873 uint64_t __attribute__((export_name("TS_TxOut_new"))) TS_TxOut_new(int8_tArray script_pubkey, int64_t value) {
11874 LDKCVec_u8Z script_pubkey_ref;
11875 script_pubkey_ref.datalen = script_pubkey->arr_len;
11876 script_pubkey_ref.data = MALLOC(script_pubkey_ref.datalen, "LDKCVec_u8Z Bytes");
11877 memcpy(script_pubkey_ref.data, script_pubkey->elems, script_pubkey_ref.datalen); FREE(script_pubkey);
11878 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11879 *ret_ref = TxOut_new(script_pubkey_ref, value);
11880 return tag_ptr(ret_ref, true);
11883 void __attribute__((export_name("TS_TxOut_free"))) TS_TxOut_free(uint64_t _res) {
11884 if (!ptr_is_owned(_res)) return;
11885 void* _res_ptr = untag_ptr(_res);
11886 CHECK_ACCESS(_res_ptr);
11887 LDKTxOut _res_conv = *(LDKTxOut*)(_res_ptr);
11888 FREE(untag_ptr(_res));
11889 TxOut_free(_res_conv);
11892 static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
11893 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11894 *ret_ref = TxOut_clone(arg);
11895 return tag_ptr(ret_ref, true);
11897 int64_t __attribute__((export_name("TS_TxOut_clone_ptr"))) TS_TxOut_clone_ptr(uint64_t arg) {
11898 LDKTxOut* arg_conv = (LDKTxOut*)untag_ptr(arg);
11899 int64_t ret_conv = TxOut_clone_ptr(arg_conv);
11903 uint64_t __attribute__((export_name("TS_TxOut_clone"))) TS_TxOut_clone(uint64_t orig) {
11904 LDKTxOut* orig_conv = (LDKTxOut*)untag_ptr(orig);
11905 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11906 *ret_ref = TxOut_clone(orig_conv);
11907 return tag_ptr(ret_ref, true);
11910 void __attribute__((export_name("TS_Str_free"))) TS_Str_free(jstring _res) {
11911 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
11915 uint64_t __attribute__((export_name("TS_COption_DurationZ_some"))) TS_COption_DurationZ_some(int64_t o) {
11916 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11917 *ret_copy = COption_DurationZ_some(o);
11918 uint64_t ret_ref = tag_ptr(ret_copy, true);
11922 uint64_t __attribute__((export_name("TS_COption_DurationZ_none"))) TS_COption_DurationZ_none() {
11923 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11924 *ret_copy = COption_DurationZ_none();
11925 uint64_t ret_ref = tag_ptr(ret_copy, true);
11929 void __attribute__((export_name("TS_COption_DurationZ_free"))) TS_COption_DurationZ_free(uint64_t _res) {
11930 if (!ptr_is_owned(_res)) return;
11931 void* _res_ptr = untag_ptr(_res);
11932 CHECK_ACCESS(_res_ptr);
11933 LDKCOption_DurationZ _res_conv = *(LDKCOption_DurationZ*)(_res_ptr);
11934 FREE(untag_ptr(_res));
11935 COption_DurationZ_free(_res_conv);
11938 static inline uint64_t COption_DurationZ_clone_ptr(LDKCOption_DurationZ *NONNULL_PTR arg) {
11939 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11940 *ret_copy = COption_DurationZ_clone(arg);
11941 uint64_t ret_ref = tag_ptr(ret_copy, true);
11944 int64_t __attribute__((export_name("TS_COption_DurationZ_clone_ptr"))) TS_COption_DurationZ_clone_ptr(uint64_t arg) {
11945 LDKCOption_DurationZ* arg_conv = (LDKCOption_DurationZ*)untag_ptr(arg);
11946 int64_t ret_conv = COption_DurationZ_clone_ptr(arg_conv);
11950 uint64_t __attribute__((export_name("TS_COption_DurationZ_clone"))) TS_COption_DurationZ_clone(uint64_t orig) {
11951 LDKCOption_DurationZ* orig_conv = (LDKCOption_DurationZ*)untag_ptr(orig);
11952 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11953 *ret_copy = COption_DurationZ_clone(orig_conv);
11954 uint64_t ret_ref = tag_ptr(ret_copy, true);
11958 void __attribute__((export_name("TS_CVec_BlindedPathZ_free"))) TS_CVec_BlindedPathZ_free(uint64_tArray _res) {
11959 LDKCVec_BlindedPathZ _res_constr;
11960 _res_constr.datalen = _res->arr_len;
11961 if (_res_constr.datalen > 0)
11962 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBlindedPath), "LDKCVec_BlindedPathZ Elements");
11964 _res_constr.data = NULL;
11965 uint64_t* _res_vals = _res->elems;
11966 for (size_t n = 0; n < _res_constr.datalen; n++) {
11967 uint64_t _res_conv_13 = _res_vals[n];
11968 LDKBlindedPath _res_conv_13_conv;
11969 _res_conv_13_conv.inner = untag_ptr(_res_conv_13);
11970 _res_conv_13_conv.is_owned = ptr_is_owned(_res_conv_13);
11971 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_13_conv);
11972 _res_constr.data[n] = _res_conv_13_conv;
11975 CVec_BlindedPathZ_free(_res_constr);
11978 uint64_t __attribute__((export_name("TS_COption_u64Z_some"))) TS_COption_u64Z_some(int64_t o) {
11979 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
11980 *ret_copy = COption_u64Z_some(o);
11981 uint64_t ret_ref = tag_ptr(ret_copy, true);
11985 uint64_t __attribute__((export_name("TS_COption_u64Z_none"))) TS_COption_u64Z_none() {
11986 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
11987 *ret_copy = COption_u64Z_none();
11988 uint64_t ret_ref = tag_ptr(ret_copy, true);
11992 void __attribute__((export_name("TS_COption_u64Z_free"))) TS_COption_u64Z_free(uint64_t _res) {
11993 if (!ptr_is_owned(_res)) return;
11994 void* _res_ptr = untag_ptr(_res);
11995 CHECK_ACCESS(_res_ptr);
11996 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(_res_ptr);
11997 FREE(untag_ptr(_res));
11998 COption_u64Z_free(_res_conv);
12001 static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
12002 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12003 *ret_copy = COption_u64Z_clone(arg);
12004 uint64_t ret_ref = tag_ptr(ret_copy, true);
12007 int64_t __attribute__((export_name("TS_COption_u64Z_clone_ptr"))) TS_COption_u64Z_clone_ptr(uint64_t arg) {
12008 LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)untag_ptr(arg);
12009 int64_t ret_conv = COption_u64Z_clone_ptr(arg_conv);
12013 uint64_t __attribute__((export_name("TS_COption_u64Z_clone"))) TS_COption_u64Z_clone(uint64_t orig) {
12014 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)untag_ptr(orig);
12015 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12016 *ret_copy = COption_u64Z_clone(orig_conv);
12017 uint64_t ret_ref = tag_ptr(ret_copy, true);
12021 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_ok"))) TS_CResult_NoneAPIErrorZ_ok() {
12022 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12023 *ret_conv = CResult_NoneAPIErrorZ_ok();
12024 return tag_ptr(ret_conv, true);
12027 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_err"))) TS_CResult_NoneAPIErrorZ_err(uint64_t e) {
12028 void* e_ptr = untag_ptr(e);
12029 CHECK_ACCESS(e_ptr);
12030 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
12031 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
12032 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12033 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
12034 return tag_ptr(ret_conv, true);
12037 jboolean __attribute__((export_name("TS_CResult_NoneAPIErrorZ_is_ok"))) TS_CResult_NoneAPIErrorZ_is_ok(uint64_t o) {
12038 LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(o);
12039 jboolean ret_conv = CResult_NoneAPIErrorZ_is_ok(o_conv);
12043 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_free"))) TS_CResult_NoneAPIErrorZ_free(uint64_t _res) {
12044 if (!ptr_is_owned(_res)) return;
12045 void* _res_ptr = untag_ptr(_res);
12046 CHECK_ACCESS(_res_ptr);
12047 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_ptr);
12048 FREE(untag_ptr(_res));
12049 CResult_NoneAPIErrorZ_free(_res_conv);
12052 static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
12053 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12054 *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
12055 return tag_ptr(ret_conv, true);
12057 int64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone_ptr"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint64_t arg) {
12058 LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(arg);
12059 int64_t ret_conv = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
12063 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone"))) TS_CResult_NoneAPIErrorZ_clone(uint64_t orig) {
12064 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(orig);
12065 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12066 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
12067 return tag_ptr(ret_conv, true);
12070 void __attribute__((export_name("TS_CVec_CResult_NoneAPIErrorZZ_free"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint64_tArray _res) {
12071 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
12072 _res_constr.datalen = _res->arr_len;
12073 if (_res_constr.datalen > 0)
12074 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
12076 _res_constr.data = NULL;
12077 uint64_t* _res_vals = _res->elems;
12078 for (size_t w = 0; w < _res_constr.datalen; w++) {
12079 uint64_t _res_conv_22 = _res_vals[w];
12080 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
12081 CHECK_ACCESS(_res_conv_22_ptr);
12082 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_conv_22_ptr);
12083 FREE(untag_ptr(_res_conv_22));
12084 _res_constr.data[w] = _res_conv_22_conv;
12087 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
12090 void __attribute__((export_name("TS_CVec_APIErrorZ_free"))) TS_CVec_APIErrorZ_free(uint64_tArray _res) {
12091 LDKCVec_APIErrorZ _res_constr;
12092 _res_constr.datalen = _res->arr_len;
12093 if (_res_constr.datalen > 0)
12094 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
12096 _res_constr.data = NULL;
12097 uint64_t* _res_vals = _res->elems;
12098 for (size_t k = 0; k < _res_constr.datalen; k++) {
12099 uint64_t _res_conv_10 = _res_vals[k];
12100 void* _res_conv_10_ptr = untag_ptr(_res_conv_10);
12101 CHECK_ACCESS(_res_conv_10_ptr);
12102 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(_res_conv_10_ptr);
12103 FREE(untag_ptr(_res_conv_10));
12104 _res_constr.data[k] = _res_conv_10_conv;
12107 CVec_APIErrorZ_free(_res_constr);
12110 void __attribute__((export_name("TS_CVec_u8Z_free"))) TS_CVec_u8Z_free(int8_tArray _res) {
12111 LDKCVec_u8Z _res_ref;
12112 _res_ref.datalen = _res->arr_len;
12113 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
12114 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
12115 CVec_u8Z_free(_res_ref);
12118 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_some"))) TS_COption_CVec_u8ZZ_some(int8_tArray o) {
12120 o_ref.datalen = o->arr_len;
12121 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
12122 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
12123 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12124 *ret_copy = COption_CVec_u8ZZ_some(o_ref);
12125 uint64_t ret_ref = tag_ptr(ret_copy, true);
12129 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_none"))) TS_COption_CVec_u8ZZ_none() {
12130 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12131 *ret_copy = COption_CVec_u8ZZ_none();
12132 uint64_t ret_ref = tag_ptr(ret_copy, true);
12136 void __attribute__((export_name("TS_COption_CVec_u8ZZ_free"))) TS_COption_CVec_u8ZZ_free(uint64_t _res) {
12137 if (!ptr_is_owned(_res)) return;
12138 void* _res_ptr = untag_ptr(_res);
12139 CHECK_ACCESS(_res_ptr);
12140 LDKCOption_CVec_u8ZZ _res_conv = *(LDKCOption_CVec_u8ZZ*)(_res_ptr);
12141 FREE(untag_ptr(_res));
12142 COption_CVec_u8ZZ_free(_res_conv);
12145 static inline uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg) {
12146 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12147 *ret_copy = COption_CVec_u8ZZ_clone(arg);
12148 uint64_t ret_ref = tag_ptr(ret_copy, true);
12151 int64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_clone_ptr"))) TS_COption_CVec_u8ZZ_clone_ptr(uint64_t arg) {
12152 LDKCOption_CVec_u8ZZ* arg_conv = (LDKCOption_CVec_u8ZZ*)untag_ptr(arg);
12153 int64_t ret_conv = COption_CVec_u8ZZ_clone_ptr(arg_conv);
12157 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_clone"))) TS_COption_CVec_u8ZZ_clone(uint64_t orig) {
12158 LDKCOption_CVec_u8ZZ* orig_conv = (LDKCOption_CVec_u8ZZ*)untag_ptr(orig);
12159 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12160 *ret_copy = COption_CVec_u8ZZ_clone(orig_conv);
12161 uint64_t ret_ref = tag_ptr(ret_copy, true);
12165 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(uint64_t o) {
12166 LDKRecipientOnionFields o_conv;
12167 o_conv.inner = untag_ptr(o);
12168 o_conv.is_owned = ptr_is_owned(o);
12169 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12170 o_conv = RecipientOnionFields_clone(&o_conv);
12171 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12172 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_ok(o_conv);
12173 return tag_ptr(ret_conv, true);
12176 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_err"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(uint64_t e) {
12177 void* e_ptr = untag_ptr(e);
12178 CHECK_ACCESS(e_ptr);
12179 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12180 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12181 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12182 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_err(e_conv);
12183 return tag_ptr(ret_conv, true);
12186 jboolean __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(uint64_t o) {
12187 LDKCResult_RecipientOnionFieldsDecodeErrorZ* o_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(o);
12188 jboolean ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o_conv);
12192 void __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_free"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(uint64_t _res) {
12193 if (!ptr_is_owned(_res)) return;
12194 void* _res_ptr = untag_ptr(_res);
12195 CHECK_ACCESS(_res_ptr);
12196 LDKCResult_RecipientOnionFieldsDecodeErrorZ _res_conv = *(LDKCResult_RecipientOnionFieldsDecodeErrorZ*)(_res_ptr);
12197 FREE(untag_ptr(_res));
12198 CResult_RecipientOnionFieldsDecodeErrorZ_free(_res_conv);
12201 static inline uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg) {
12202 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12203 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone(arg);
12204 return tag_ptr(ret_conv, true);
12206 int64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(uint64_t arg) {
12207 LDKCResult_RecipientOnionFieldsDecodeErrorZ* arg_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(arg);
12208 int64_t ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg_conv);
12212 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(uint64_t orig) {
12213 LDKCResult_RecipientOnionFieldsDecodeErrorZ* orig_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(orig);
12214 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12215 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig_conv);
12216 return tag_ptr(ret_conv, true);
12219 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_some"))) TS_COption_HTLCClaimZ_some(uint32_t o) {
12220 LDKHTLCClaim o_conv = LDKHTLCClaim_from_js(o);
12221 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
12222 *ret_copy = COption_HTLCClaimZ_some(o_conv);
12223 uint64_t ret_ref = tag_ptr(ret_copy, true);
12227 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_none"))) TS_COption_HTLCClaimZ_none() {
12228 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
12229 *ret_copy = COption_HTLCClaimZ_none();
12230 uint64_t ret_ref = tag_ptr(ret_copy, true);
12234 void __attribute__((export_name("TS_COption_HTLCClaimZ_free"))) TS_COption_HTLCClaimZ_free(uint64_t _res) {
12235 if (!ptr_is_owned(_res)) return;
12236 void* _res_ptr = untag_ptr(_res);
12237 CHECK_ACCESS(_res_ptr);
12238 LDKCOption_HTLCClaimZ _res_conv = *(LDKCOption_HTLCClaimZ*)(_res_ptr);
12239 FREE(untag_ptr(_res));
12240 COption_HTLCClaimZ_free(_res_conv);
12243 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_ok"))) TS_CResult_NoneNoneZ_ok() {
12244 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12245 *ret_conv = CResult_NoneNoneZ_ok();
12246 return tag_ptr(ret_conv, true);
12249 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_err"))) TS_CResult_NoneNoneZ_err() {
12250 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12251 *ret_conv = CResult_NoneNoneZ_err();
12252 return tag_ptr(ret_conv, true);
12255 jboolean __attribute__((export_name("TS_CResult_NoneNoneZ_is_ok"))) TS_CResult_NoneNoneZ_is_ok(uint64_t o) {
12256 LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)untag_ptr(o);
12257 jboolean ret_conv = CResult_NoneNoneZ_is_ok(o_conv);
12261 void __attribute__((export_name("TS_CResult_NoneNoneZ_free"))) TS_CResult_NoneNoneZ_free(uint64_t _res) {
12262 if (!ptr_is_owned(_res)) return;
12263 void* _res_ptr = untag_ptr(_res);
12264 CHECK_ACCESS(_res_ptr);
12265 LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(_res_ptr);
12266 FREE(untag_ptr(_res));
12267 CResult_NoneNoneZ_free(_res_conv);
12270 static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
12271 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12272 *ret_conv = CResult_NoneNoneZ_clone(arg);
12273 return tag_ptr(ret_conv, true);
12275 int64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone_ptr"))) TS_CResult_NoneNoneZ_clone_ptr(uint64_t arg) {
12276 LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)untag_ptr(arg);
12277 int64_t ret_conv = CResult_NoneNoneZ_clone_ptr(arg_conv);
12281 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone"))) TS_CResult_NoneNoneZ_clone(uint64_t orig) {
12282 LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)untag_ptr(orig);
12283 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12284 *ret_conv = CResult_NoneNoneZ_clone(orig_conv);
12285 return tag_ptr(ret_conv, true);
12288 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(uint64_t o) {
12289 LDKCounterpartyCommitmentSecrets o_conv;
12290 o_conv.inner = untag_ptr(o);
12291 o_conv.is_owned = ptr_is_owned(o);
12292 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12293 o_conv = CounterpartyCommitmentSecrets_clone(&o_conv);
12294 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12295 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o_conv);
12296 return tag_ptr(ret_conv, true);
12299 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(uint64_t e) {
12300 void* e_ptr = untag_ptr(e);
12301 CHECK_ACCESS(e_ptr);
12302 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12303 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12304 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12305 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e_conv);
12306 return tag_ptr(ret_conv, true);
12309 jboolean __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(uint64_t o) {
12310 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* o_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(o);
12311 jboolean ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o_conv);
12315 void __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(uint64_t _res) {
12316 if (!ptr_is_owned(_res)) return;
12317 void* _res_ptr = untag_ptr(_res);
12318 CHECK_ACCESS(_res_ptr);
12319 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(_res_ptr);
12320 FREE(untag_ptr(_res));
12321 CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res_conv);
12324 static inline uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg) {
12325 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12326 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(arg);
12327 return tag_ptr(ret_conv, true);
12329 int64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(uint64_t arg) {
12330 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(arg);
12331 int64_t ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg_conv);
12335 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(uint64_t orig) {
12336 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(orig);
12337 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12338 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig_conv);
12339 return tag_ptr(ret_conv, true);
12342 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_ok(uint64_t o) {
12343 LDKTxCreationKeys o_conv;
12344 o_conv.inner = untag_ptr(o);
12345 o_conv.is_owned = ptr_is_owned(o);
12346 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12347 o_conv = TxCreationKeys_clone(&o_conv);
12348 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12349 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
12350 return tag_ptr(ret_conv, true);
12353 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_err(uint64_t e) {
12354 void* e_ptr = untag_ptr(e);
12355 CHECK_ACCESS(e_ptr);
12356 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12357 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12358 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12359 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
12360 return tag_ptr(ret_conv, true);
12363 jboolean __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_is_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint64_t o) {
12364 LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(o);
12365 jboolean ret_conv = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
12369 void __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_free"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint64_t _res) {
12370 if (!ptr_is_owned(_res)) return;
12371 void* _res_ptr = untag_ptr(_res);
12372 CHECK_ACCESS(_res_ptr);
12373 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(_res_ptr);
12374 FREE(untag_ptr(_res));
12375 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
12378 static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
12379 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12380 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
12381 return tag_ptr(ret_conv, true);
12383 int64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
12384 LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(arg);
12385 int64_t ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
12389 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint64_t orig) {
12390 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(orig);
12391 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12392 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
12393 return tag_ptr(ret_conv, true);
12396 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(uint64_t o) {
12397 LDKChannelPublicKeys o_conv;
12398 o_conv.inner = untag_ptr(o);
12399 o_conv.is_owned = ptr_is_owned(o);
12400 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12401 o_conv = ChannelPublicKeys_clone(&o_conv);
12402 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12403 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
12404 return tag_ptr(ret_conv, true);
12407 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_err(uint64_t e) {
12408 void* e_ptr = untag_ptr(e);
12409 CHECK_ACCESS(e_ptr);
12410 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12411 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12412 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12413 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
12414 return tag_ptr(ret_conv, true);
12417 jboolean __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint64_t o) {
12418 LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(o);
12419 jboolean ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
12423 void __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_free"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint64_t _res) {
12424 if (!ptr_is_owned(_res)) return;
12425 void* _res_ptr = untag_ptr(_res);
12426 CHECK_ACCESS(_res_ptr);
12427 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(_res_ptr);
12428 FREE(untag_ptr(_res));
12429 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
12432 static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
12433 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12434 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
12435 return tag_ptr(ret_conv, true);
12437 int64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
12438 LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(arg);
12439 int64_t ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
12443 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint64_t orig) {
12444 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(orig);
12445 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12446 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
12447 return tag_ptr(ret_conv, true);
12450 uint64_t __attribute__((export_name("TS_COption_u32Z_some"))) TS_COption_u32Z_some(int32_t o) {
12451 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12452 *ret_copy = COption_u32Z_some(o);
12453 uint64_t ret_ref = tag_ptr(ret_copy, true);
12457 uint64_t __attribute__((export_name("TS_COption_u32Z_none"))) TS_COption_u32Z_none() {
12458 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12459 *ret_copy = COption_u32Z_none();
12460 uint64_t ret_ref = tag_ptr(ret_copy, true);
12464 void __attribute__((export_name("TS_COption_u32Z_free"))) TS_COption_u32Z_free(uint64_t _res) {
12465 if (!ptr_is_owned(_res)) return;
12466 void* _res_ptr = untag_ptr(_res);
12467 CHECK_ACCESS(_res_ptr);
12468 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(_res_ptr);
12469 FREE(untag_ptr(_res));
12470 COption_u32Z_free(_res_conv);
12473 static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
12474 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12475 *ret_copy = COption_u32Z_clone(arg);
12476 uint64_t ret_ref = tag_ptr(ret_copy, true);
12479 int64_t __attribute__((export_name("TS_COption_u32Z_clone_ptr"))) TS_COption_u32Z_clone_ptr(uint64_t arg) {
12480 LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)untag_ptr(arg);
12481 int64_t ret_conv = COption_u32Z_clone_ptr(arg_conv);
12485 uint64_t __attribute__((export_name("TS_COption_u32Z_clone"))) TS_COption_u32Z_clone(uint64_t orig) {
12486 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)untag_ptr(orig);
12487 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12488 *ret_copy = COption_u32Z_clone(orig_conv);
12489 uint64_t ret_ref = tag_ptr(ret_copy, true);
12493 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(uint64_t o) {
12494 LDKHTLCOutputInCommitment o_conv;
12495 o_conv.inner = untag_ptr(o);
12496 o_conv.is_owned = ptr_is_owned(o);
12497 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12498 o_conv = HTLCOutputInCommitment_clone(&o_conv);
12499 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12500 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
12501 return tag_ptr(ret_conv, true);
12504 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(uint64_t e) {
12505 void* e_ptr = untag_ptr(e);
12506 CHECK_ACCESS(e_ptr);
12507 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12508 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12509 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12510 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
12511 return tag_ptr(ret_conv, true);
12514 jboolean __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint64_t o) {
12515 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(o);
12516 jboolean ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
12520 void __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint64_t _res) {
12521 if (!ptr_is_owned(_res)) return;
12522 void* _res_ptr = untag_ptr(_res);
12523 CHECK_ACCESS(_res_ptr);
12524 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(_res_ptr);
12525 FREE(untag_ptr(_res));
12526 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
12529 static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
12530 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12531 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
12532 return tag_ptr(ret_conv, true);
12534 int64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint64_t arg) {
12535 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(arg);
12536 int64_t ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
12540 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint64_t orig) {
12541 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(orig);
12542 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12543 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
12544 return tag_ptr(ret_conv, true);
12547 uint32_t __attribute__((export_name("TS_COption_NoneZ_some"))) TS_COption_NoneZ_some() {
12548 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_some());
12552 uint32_t __attribute__((export_name("TS_COption_NoneZ_none"))) TS_COption_NoneZ_none() {
12553 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_none());
12557 void __attribute__((export_name("TS_COption_NoneZ_free"))) TS_COption_NoneZ_free(uint32_t _res) {
12558 LDKCOption_NoneZ _res_conv = LDKCOption_NoneZ_from_js(_res);
12559 COption_NoneZ_free(_res_conv);
12562 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
12563 LDKCounterpartyChannelTransactionParameters o_conv;
12564 o_conv.inner = untag_ptr(o);
12565 o_conv.is_owned = ptr_is_owned(o);
12566 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12567 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
12568 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12569 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
12570 return tag_ptr(ret_conv, true);
12573 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
12574 void* e_ptr = untag_ptr(e);
12575 CHECK_ACCESS(e_ptr);
12576 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12577 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12578 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12579 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
12580 return tag_ptr(ret_conv, true);
12583 jboolean __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
12584 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
12585 jboolean ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
12589 void __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
12590 if (!ptr_is_owned(_res)) return;
12591 void* _res_ptr = untag_ptr(_res);
12592 CHECK_ACCESS(_res_ptr);
12593 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
12594 FREE(untag_ptr(_res));
12595 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
12598 static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
12599 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12600 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
12601 return tag_ptr(ret_conv, true);
12603 int64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
12604 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
12605 int64_t ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
12609 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
12610 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
12611 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12612 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
12613 return tag_ptr(ret_conv, true);
12616 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
12617 LDKChannelTransactionParameters o_conv;
12618 o_conv.inner = untag_ptr(o);
12619 o_conv.is_owned = ptr_is_owned(o);
12620 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12621 o_conv = ChannelTransactionParameters_clone(&o_conv);
12622 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12623 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
12624 return tag_ptr(ret_conv, true);
12627 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
12628 void* e_ptr = untag_ptr(e);
12629 CHECK_ACCESS(e_ptr);
12630 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12631 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12632 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12633 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
12634 return tag_ptr(ret_conv, true);
12637 jboolean __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
12638 LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
12639 jboolean ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
12643 void __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
12644 if (!ptr_is_owned(_res)) return;
12645 void* _res_ptr = untag_ptr(_res);
12646 CHECK_ACCESS(_res_ptr);
12647 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
12648 FREE(untag_ptr(_res));
12649 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
12652 static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
12653 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12654 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
12655 return tag_ptr(ret_conv, true);
12657 int64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
12658 LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
12659 int64_t ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
12663 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
12664 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
12665 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12666 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
12667 return tag_ptr(ret_conv, true);
12670 void __attribute__((export_name("TS_CVec_SignatureZ_free"))) TS_CVec_SignatureZ_free(ptrArray _res) {
12671 LDKCVec_SignatureZ _res_constr;
12672 _res_constr.datalen = _res->arr_len;
12673 if (_res_constr.datalen > 0)
12674 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12676 _res_constr.data = NULL;
12677 int8_tArray* _res_vals = (void*) _res->elems;
12678 for (size_t m = 0; m < _res_constr.datalen; m++) {
12679 int8_tArray _res_conv_12 = _res_vals[m];
12680 LDKSignature _res_conv_12_ref;
12681 CHECK(_res_conv_12->arr_len == 64);
12682 memcpy(_res_conv_12_ref.compact_form, _res_conv_12->elems, 64); FREE(_res_conv_12);
12683 _res_constr.data[m] = _res_conv_12_ref;
12686 CVec_SignatureZ_free(_res_constr);
12689 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12690 LDKHolderCommitmentTransaction o_conv;
12691 o_conv.inner = untag_ptr(o);
12692 o_conv.is_owned = ptr_is_owned(o);
12693 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12694 o_conv = HolderCommitmentTransaction_clone(&o_conv);
12695 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12696 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
12697 return tag_ptr(ret_conv, true);
12700 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12701 void* e_ptr = untag_ptr(e);
12702 CHECK_ACCESS(e_ptr);
12703 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12704 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12705 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12706 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
12707 return tag_ptr(ret_conv, true);
12710 jboolean __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12711 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12712 jboolean ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12716 void __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12717 if (!ptr_is_owned(_res)) return;
12718 void* _res_ptr = untag_ptr(_res);
12719 CHECK_ACCESS(_res_ptr);
12720 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12721 FREE(untag_ptr(_res));
12722 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
12725 static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12726 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12727 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
12728 return tag_ptr(ret_conv, true);
12730 int64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12731 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12732 int64_t ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12736 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12737 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12738 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12739 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12740 return tag_ptr(ret_conv, true);
12743 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12744 LDKBuiltCommitmentTransaction o_conv;
12745 o_conv.inner = untag_ptr(o);
12746 o_conv.is_owned = ptr_is_owned(o);
12747 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12748 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
12749 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12750 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
12751 return tag_ptr(ret_conv, true);
12754 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12755 void* e_ptr = untag_ptr(e);
12756 CHECK_ACCESS(e_ptr);
12757 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12758 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12759 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12760 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
12761 return tag_ptr(ret_conv, true);
12764 jboolean __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12765 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12766 jboolean ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12770 void __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12771 if (!ptr_is_owned(_res)) return;
12772 void* _res_ptr = untag_ptr(_res);
12773 CHECK_ACCESS(_res_ptr);
12774 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12775 FREE(untag_ptr(_res));
12776 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
12779 static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12780 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12781 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
12782 return tag_ptr(ret_conv, true);
12784 int64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12785 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12786 int64_t ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12790 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12791 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12792 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12793 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12794 return tag_ptr(ret_conv, true);
12797 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_ok(uint64_t o) {
12798 LDKTrustedClosingTransaction o_conv;
12799 o_conv.inner = untag_ptr(o);
12800 o_conv.is_owned = ptr_is_owned(o);
12801 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12802 // WARNING: we need a move here but no clone is available for LDKTrustedClosingTransaction
12804 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12805 *ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
12806 return tag_ptr(ret_conv, true);
12809 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_err"))) TS_CResult_TrustedClosingTransactionNoneZ_err() {
12810 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12811 *ret_conv = CResult_TrustedClosingTransactionNoneZ_err();
12812 return tag_ptr(ret_conv, true);
12815 jboolean __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_is_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint64_t o) {
12816 LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(o);
12817 jboolean ret_conv = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
12821 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_free"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint64_t _res) {
12822 if (!ptr_is_owned(_res)) return;
12823 void* _res_ptr = untag_ptr(_res);
12824 CHECK_ACCESS(_res_ptr);
12825 LDKCResult_TrustedClosingTransactionNoneZ _res_conv = *(LDKCResult_TrustedClosingTransactionNoneZ*)(_res_ptr);
12826 FREE(untag_ptr(_res));
12827 CResult_TrustedClosingTransactionNoneZ_free(_res_conv);
12830 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12831 LDKCommitmentTransaction o_conv;
12832 o_conv.inner = untag_ptr(o);
12833 o_conv.is_owned = ptr_is_owned(o);
12834 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12835 o_conv = CommitmentTransaction_clone(&o_conv);
12836 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12837 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
12838 return tag_ptr(ret_conv, true);
12841 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12842 void* e_ptr = untag_ptr(e);
12843 CHECK_ACCESS(e_ptr);
12844 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12845 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12846 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12847 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
12848 return tag_ptr(ret_conv, true);
12851 jboolean __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12852 LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12853 jboolean ret_conv = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12857 void __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_free"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12858 if (!ptr_is_owned(_res)) return;
12859 void* _res_ptr = untag_ptr(_res);
12860 CHECK_ACCESS(_res_ptr);
12861 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(_res_ptr);
12862 FREE(untag_ptr(_res));
12863 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
12866 static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12867 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12868 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
12869 return tag_ptr(ret_conv, true);
12871 int64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12872 LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12873 int64_t ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12877 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12878 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12879 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12880 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
12881 return tag_ptr(ret_conv, true);
12884 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_ok(uint64_t o) {
12885 LDKTrustedCommitmentTransaction o_conv;
12886 o_conv.inner = untag_ptr(o);
12887 o_conv.is_owned = ptr_is_owned(o);
12888 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12889 // WARNING: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
12891 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12892 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
12893 return tag_ptr(ret_conv, true);
12896 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
12897 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12898 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
12899 return tag_ptr(ret_conv, true);
12902 jboolean __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint64_t o) {
12903 LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(o);
12904 jboolean ret_conv = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
12908 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_free"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint64_t _res) {
12909 if (!ptr_is_owned(_res)) return;
12910 void* _res_ptr = untag_ptr(_res);
12911 CHECK_ACCESS(_res_ptr);
12912 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(_res_ptr);
12913 FREE(untag_ptr(_res));
12914 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
12917 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_ok"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
12918 LDKCVec_SignatureZ o_constr;
12919 o_constr.datalen = o->arr_len;
12920 if (o_constr.datalen > 0)
12921 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12923 o_constr.data = NULL;
12924 int8_tArray* o_vals = (void*) o->elems;
12925 for (size_t m = 0; m < o_constr.datalen; m++) {
12926 int8_tArray o_conv_12 = o_vals[m];
12927 LDKSignature o_conv_12_ref;
12928 CHECK(o_conv_12->arr_len == 64);
12929 memcpy(o_conv_12_ref.compact_form, o_conv_12->elems, 64); FREE(o_conv_12);
12930 o_constr.data[m] = o_conv_12_ref;
12933 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12934 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
12935 return tag_ptr(ret_conv, true);
12938 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_err"))) TS_CResult_CVec_SignatureZNoneZ_err() {
12939 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12940 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
12941 return tag_ptr(ret_conv, true);
12944 jboolean __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_is_ok"))) TS_CResult_CVec_SignatureZNoneZ_is_ok(uint64_t o) {
12945 LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(o);
12946 jboolean ret_conv = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
12950 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_free"))) TS_CResult_CVec_SignatureZNoneZ_free(uint64_t _res) {
12951 if (!ptr_is_owned(_res)) return;
12952 void* _res_ptr = untag_ptr(_res);
12953 CHECK_ACCESS(_res_ptr);
12954 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(_res_ptr);
12955 FREE(untag_ptr(_res));
12956 CResult_CVec_SignatureZNoneZ_free(_res_conv);
12959 static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
12960 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12961 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
12962 return tag_ptr(ret_conv, true);
12964 int64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone_ptr"))) TS_CResult_CVec_SignatureZNoneZ_clone_ptr(uint64_t arg) {
12965 LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(arg);
12966 int64_t ret_conv = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
12970 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint64_t orig) {
12971 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(orig);
12972 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12973 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
12974 return tag_ptr(ret_conv, true);
12977 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_ok(uint64_t o) {
12978 LDKShutdownScript o_conv;
12979 o_conv.inner = untag_ptr(o);
12980 o_conv.is_owned = ptr_is_owned(o);
12981 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12982 o_conv = ShutdownScript_clone(&o_conv);
12983 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12984 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
12985 return tag_ptr(ret_conv, true);
12988 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_err(uint64_t e) {
12989 void* e_ptr = untag_ptr(e);
12990 CHECK_ACCESS(e_ptr);
12991 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12992 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12993 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12994 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
12995 return tag_ptr(ret_conv, true);
12998 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_is_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint64_t o) {
12999 LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(o);
13000 jboolean ret_conv = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
13004 void __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_free"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint64_t _res) {
13005 if (!ptr_is_owned(_res)) return;
13006 void* _res_ptr = untag_ptr(_res);
13007 CHECK_ACCESS(_res_ptr);
13008 LDKCResult_ShutdownScriptDecodeErrorZ _res_conv = *(LDKCResult_ShutdownScriptDecodeErrorZ*)(_res_ptr);
13009 FREE(untag_ptr(_res));
13010 CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
13013 static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
13014 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
13015 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
13016 return tag_ptr(ret_conv, true);
13018 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint64_t arg) {
13019 LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(arg);
13020 int64_t ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
13024 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint64_t orig) {
13025 LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(orig);
13026 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
13027 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(orig_conv);
13028 return tag_ptr(ret_conv, true);
13031 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(uint64_t o) {
13032 LDKShutdownScript o_conv;
13033 o_conv.inner = untag_ptr(o);
13034 o_conv.is_owned = ptr_is_owned(o);
13035 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13036 o_conv = ShutdownScript_clone(&o_conv);
13037 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13038 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
13039 return tag_ptr(ret_conv, true);
13042 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(uint64_t e) {
13043 LDKInvalidShutdownScript e_conv;
13044 e_conv.inner = untag_ptr(e);
13045 e_conv.is_owned = ptr_is_owned(e);
13046 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13047 e_conv = InvalidShutdownScript_clone(&e_conv);
13048 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13049 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
13050 return tag_ptr(ret_conv, true);
13053 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint64_t o) {
13054 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(o);
13055 jboolean ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
13059 void __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint64_t _res) {
13060 if (!ptr_is_owned(_res)) return;
13061 void* _res_ptr = untag_ptr(_res);
13062 CHECK_ACCESS(_res_ptr);
13063 LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res_conv = *(LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(_res_ptr);
13064 FREE(untag_ptr(_res));
13065 CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
13068 static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
13069 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13070 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
13071 return tag_ptr(ret_conv, true);
13073 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint64_t arg) {
13074 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(arg);
13075 int64_t ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
13079 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint64_t orig) {
13080 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(orig);
13081 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13082 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig_conv);
13083 return tag_ptr(ret_conv, true);
13086 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_ok(uint64_t o) {
13087 LDKBlindedPayInfo o_conv;
13088 o_conv.inner = untag_ptr(o);
13089 o_conv.is_owned = ptr_is_owned(o);
13090 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13091 o_conv = BlindedPayInfo_clone(&o_conv);
13092 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13093 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_ok(o_conv);
13094 return tag_ptr(ret_conv, true);
13097 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_err"))) TS_CResult_BlindedPayInfoDecodeErrorZ_err(uint64_t e) {
13098 void* e_ptr = untag_ptr(e);
13099 CHECK_ACCESS(e_ptr);
13100 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13101 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13102 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13103 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_err(e_conv);
13104 return tag_ptr(ret_conv, true);
13107 jboolean __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(uint64_t o) {
13108 LDKCResult_BlindedPayInfoDecodeErrorZ* o_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(o);
13109 jboolean ret_conv = CResult_BlindedPayInfoDecodeErrorZ_is_ok(o_conv);
13113 void __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_free"))) TS_CResult_BlindedPayInfoDecodeErrorZ_free(uint64_t _res) {
13114 if (!ptr_is_owned(_res)) return;
13115 void* _res_ptr = untag_ptr(_res);
13116 CHECK_ACCESS(_res_ptr);
13117 LDKCResult_BlindedPayInfoDecodeErrorZ _res_conv = *(LDKCResult_BlindedPayInfoDecodeErrorZ*)(_res_ptr);
13118 FREE(untag_ptr(_res));
13119 CResult_BlindedPayInfoDecodeErrorZ_free(_res_conv);
13122 static inline uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg) {
13123 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13124 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone(arg);
13125 return tag_ptr(ret_conv, true);
13127 int64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
13128 LDKCResult_BlindedPayInfoDecodeErrorZ* arg_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(arg);
13129 int64_t ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg_conv);
13133 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_clone"))) TS_CResult_BlindedPayInfoDecodeErrorZ_clone(uint64_t orig) {
13134 LDKCResult_BlindedPayInfoDecodeErrorZ* orig_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(orig);
13135 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13136 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone(orig_conv);
13137 return tag_ptr(ret_conv, true);
13140 void __attribute__((export_name("TS_CVec_ChannelDetailsZ_free"))) TS_CVec_ChannelDetailsZ_free(uint64_tArray _res) {
13141 LDKCVec_ChannelDetailsZ _res_constr;
13142 _res_constr.datalen = _res->arr_len;
13143 if (_res_constr.datalen > 0)
13144 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
13146 _res_constr.data = NULL;
13147 uint64_t* _res_vals = _res->elems;
13148 for (size_t q = 0; q < _res_constr.datalen; q++) {
13149 uint64_t _res_conv_16 = _res_vals[q];
13150 LDKChannelDetails _res_conv_16_conv;
13151 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
13152 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
13153 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
13154 _res_constr.data[q] = _res_conv_16_conv;
13157 CVec_ChannelDetailsZ_free(_res_constr);
13160 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_ok"))) TS_CResult_RouteLightningErrorZ_ok(uint64_t o) {
13162 o_conv.inner = untag_ptr(o);
13163 o_conv.is_owned = ptr_is_owned(o);
13164 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13165 o_conv = Route_clone(&o_conv);
13166 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13167 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
13168 return tag_ptr(ret_conv, true);
13171 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_err"))) TS_CResult_RouteLightningErrorZ_err(uint64_t e) {
13172 LDKLightningError e_conv;
13173 e_conv.inner = untag_ptr(e);
13174 e_conv.is_owned = ptr_is_owned(e);
13175 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13176 e_conv = LightningError_clone(&e_conv);
13177 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13178 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
13179 return tag_ptr(ret_conv, true);
13182 jboolean __attribute__((export_name("TS_CResult_RouteLightningErrorZ_is_ok"))) TS_CResult_RouteLightningErrorZ_is_ok(uint64_t o) {
13183 LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(o);
13184 jboolean ret_conv = CResult_RouteLightningErrorZ_is_ok(o_conv);
13188 void __attribute__((export_name("TS_CResult_RouteLightningErrorZ_free"))) TS_CResult_RouteLightningErrorZ_free(uint64_t _res) {
13189 if (!ptr_is_owned(_res)) return;
13190 void* _res_ptr = untag_ptr(_res);
13191 CHECK_ACCESS(_res_ptr);
13192 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
13193 FREE(untag_ptr(_res));
13194 CResult_RouteLightningErrorZ_free(_res_conv);
13197 static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
13198 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13199 *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
13200 return tag_ptr(ret_conv, true);
13202 int64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone_ptr"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint64_t arg) {
13203 LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(arg);
13204 int64_t ret_conv = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
13208 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone"))) TS_CResult_RouteLightningErrorZ_clone(uint64_t orig) {
13209 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(orig);
13210 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13211 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
13212 return tag_ptr(ret_conv, true);
13215 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_ok(uint64_t o) {
13216 LDKInFlightHtlcs o_conv;
13217 o_conv.inner = untag_ptr(o);
13218 o_conv.is_owned = ptr_is_owned(o);
13219 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13220 o_conv = InFlightHtlcs_clone(&o_conv);
13221 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13222 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_ok(o_conv);
13223 return tag_ptr(ret_conv, true);
13226 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_err(uint64_t e) {
13227 void* e_ptr = untag_ptr(e);
13228 CHECK_ACCESS(e_ptr);
13229 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13230 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13231 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13232 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_err(e_conv);
13233 return tag_ptr(ret_conv, true);
13236 jboolean __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(uint64_t o) {
13237 LDKCResult_InFlightHtlcsDecodeErrorZ* o_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(o);
13238 jboolean ret_conv = CResult_InFlightHtlcsDecodeErrorZ_is_ok(o_conv);
13242 void __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_free"))) TS_CResult_InFlightHtlcsDecodeErrorZ_free(uint64_t _res) {
13243 if (!ptr_is_owned(_res)) return;
13244 void* _res_ptr = untag_ptr(_res);
13245 CHECK_ACCESS(_res_ptr);
13246 LDKCResult_InFlightHtlcsDecodeErrorZ _res_conv = *(LDKCResult_InFlightHtlcsDecodeErrorZ*)(_res_ptr);
13247 FREE(untag_ptr(_res));
13248 CResult_InFlightHtlcsDecodeErrorZ_free(_res_conv);
13251 static inline uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg) {
13252 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13253 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(arg);
13254 return tag_ptr(ret_conv, true);
13256 int64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(uint64_t arg) {
13257 LDKCResult_InFlightHtlcsDecodeErrorZ* arg_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(arg);
13258 int64_t ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg_conv);
13262 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone(uint64_t orig) {
13263 LDKCResult_InFlightHtlcsDecodeErrorZ* orig_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(orig);
13264 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13265 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(orig_conv);
13266 return tag_ptr(ret_conv, true);
13269 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_ok"))) TS_CResult_RouteHopDecodeErrorZ_ok(uint64_t o) {
13270 LDKRouteHop o_conv;
13271 o_conv.inner = untag_ptr(o);
13272 o_conv.is_owned = ptr_is_owned(o);
13273 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13274 o_conv = RouteHop_clone(&o_conv);
13275 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13276 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
13277 return tag_ptr(ret_conv, true);
13280 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_err"))) TS_CResult_RouteHopDecodeErrorZ_err(uint64_t e) {
13281 void* e_ptr = untag_ptr(e);
13282 CHECK_ACCESS(e_ptr);
13283 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13284 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13285 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13286 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
13287 return tag_ptr(ret_conv, true);
13290 jboolean __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint64_t o) {
13291 LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(o);
13292 jboolean ret_conv = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
13296 void __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_free"))) TS_CResult_RouteHopDecodeErrorZ_free(uint64_t _res) {
13297 if (!ptr_is_owned(_res)) return;
13298 void* _res_ptr = untag_ptr(_res);
13299 CHECK_ACCESS(_res_ptr);
13300 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(_res_ptr);
13301 FREE(untag_ptr(_res));
13302 CResult_RouteHopDecodeErrorZ_free(_res_conv);
13305 static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
13306 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13307 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
13308 return tag_ptr(ret_conv, true);
13310 int64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint64_t arg) {
13311 LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(arg);
13312 int64_t ret_conv = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
13316 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint64_t orig) {
13317 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(orig);
13318 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13319 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
13320 return tag_ptr(ret_conv, true);
13323 void __attribute__((export_name("TS_CVec_BlindedHopZ_free"))) TS_CVec_BlindedHopZ_free(uint64_tArray _res) {
13324 LDKCVec_BlindedHopZ _res_constr;
13325 _res_constr.datalen = _res->arr_len;
13326 if (_res_constr.datalen > 0)
13327 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
13329 _res_constr.data = NULL;
13330 uint64_t* _res_vals = _res->elems;
13331 for (size_t m = 0; m < _res_constr.datalen; m++) {
13332 uint64_t _res_conv_12 = _res_vals[m];
13333 LDKBlindedHop _res_conv_12_conv;
13334 _res_conv_12_conv.inner = untag_ptr(_res_conv_12);
13335 _res_conv_12_conv.is_owned = ptr_is_owned(_res_conv_12);
13336 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv);
13337 _res_constr.data[m] = _res_conv_12_conv;
13340 CVec_BlindedHopZ_free(_res_constr);
13343 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_ok"))) TS_CResult_BlindedTailDecodeErrorZ_ok(uint64_t o) {
13344 LDKBlindedTail o_conv;
13345 o_conv.inner = untag_ptr(o);
13346 o_conv.is_owned = ptr_is_owned(o);
13347 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13348 o_conv = BlindedTail_clone(&o_conv);
13349 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13350 *ret_conv = CResult_BlindedTailDecodeErrorZ_ok(o_conv);
13351 return tag_ptr(ret_conv, true);
13354 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_err"))) TS_CResult_BlindedTailDecodeErrorZ_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_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13360 *ret_conv = CResult_BlindedTailDecodeErrorZ_err(e_conv);
13361 return tag_ptr(ret_conv, true);
13364 jboolean __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_is_ok"))) TS_CResult_BlindedTailDecodeErrorZ_is_ok(uint64_t o) {
13365 LDKCResult_BlindedTailDecodeErrorZ* o_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(o);
13366 jboolean ret_conv = CResult_BlindedTailDecodeErrorZ_is_ok(o_conv);
13370 void __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_free"))) TS_CResult_BlindedTailDecodeErrorZ_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_BlindedTailDecodeErrorZ _res_conv = *(LDKCResult_BlindedTailDecodeErrorZ*)(_res_ptr);
13375 FREE(untag_ptr(_res));
13376 CResult_BlindedTailDecodeErrorZ_free(_res_conv);
13379 static inline uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg) {
13380 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13381 *ret_conv = CResult_BlindedTailDecodeErrorZ_clone(arg);
13382 return tag_ptr(ret_conv, true);
13384 int64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(uint64_t arg) {
13385 LDKCResult_BlindedTailDecodeErrorZ* arg_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(arg);
13386 int64_t ret_conv = CResult_BlindedTailDecodeErrorZ_clone_ptr(arg_conv);
13390 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_clone"))) TS_CResult_BlindedTailDecodeErrorZ_clone(uint64_t orig) {
13391 LDKCResult_BlindedTailDecodeErrorZ* orig_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(orig);
13392 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13393 *ret_conv = CResult_BlindedTailDecodeErrorZ_clone(orig_conv);
13394 return tag_ptr(ret_conv, true);
13397 void __attribute__((export_name("TS_CVec_RouteHopZ_free"))) TS_CVec_RouteHopZ_free(uint64_tArray _res) {
13398 LDKCVec_RouteHopZ _res_constr;
13399 _res_constr.datalen = _res->arr_len;
13400 if (_res_constr.datalen > 0)
13401 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
13403 _res_constr.data = NULL;
13404 uint64_t* _res_vals = _res->elems;
13405 for (size_t k = 0; k < _res_constr.datalen; k++) {
13406 uint64_t _res_conv_10 = _res_vals[k];
13407 LDKRouteHop _res_conv_10_conv;
13408 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
13409 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
13410 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
13411 _res_constr.data[k] = _res_conv_10_conv;
13414 CVec_RouteHopZ_free(_res_constr);
13417 void __attribute__((export_name("TS_CVec_PathZ_free"))) TS_CVec_PathZ_free(uint64_tArray _res) {
13418 LDKCVec_PathZ _res_constr;
13419 _res_constr.datalen = _res->arr_len;
13420 if (_res_constr.datalen > 0)
13421 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
13423 _res_constr.data = NULL;
13424 uint64_t* _res_vals = _res->elems;
13425 for (size_t g = 0; g < _res_constr.datalen; g++) {
13426 uint64_t _res_conv_6 = _res_vals[g];
13427 LDKPath _res_conv_6_conv;
13428 _res_conv_6_conv.inner = untag_ptr(_res_conv_6);
13429 _res_conv_6_conv.is_owned = ptr_is_owned(_res_conv_6);
13430 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_6_conv);
13431 _res_constr.data[g] = _res_conv_6_conv;
13434 CVec_PathZ_free(_res_constr);
13437 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_ok"))) TS_CResult_RouteDecodeErrorZ_ok(uint64_t o) {
13439 o_conv.inner = untag_ptr(o);
13440 o_conv.is_owned = ptr_is_owned(o);
13441 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13442 o_conv = Route_clone(&o_conv);
13443 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13444 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
13445 return tag_ptr(ret_conv, true);
13448 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_err"))) TS_CResult_RouteDecodeErrorZ_err(uint64_t e) {
13449 void* e_ptr = untag_ptr(e);
13450 CHECK_ACCESS(e_ptr);
13451 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13452 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13453 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13454 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
13455 return tag_ptr(ret_conv, true);
13458 jboolean __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_is_ok"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint64_t o) {
13459 LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(o);
13460 jboolean ret_conv = CResult_RouteDecodeErrorZ_is_ok(o_conv);
13464 void __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_free"))) TS_CResult_RouteDecodeErrorZ_free(uint64_t _res) {
13465 if (!ptr_is_owned(_res)) return;
13466 void* _res_ptr = untag_ptr(_res);
13467 CHECK_ACCESS(_res_ptr);
13468 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(_res_ptr);
13469 FREE(untag_ptr(_res));
13470 CResult_RouteDecodeErrorZ_free(_res_conv);
13473 static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
13474 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13475 *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
13476 return tag_ptr(ret_conv, true);
13478 int64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone_ptr"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint64_t arg) {
13479 LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(arg);
13480 int64_t ret_conv = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
13484 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone"))) TS_CResult_RouteDecodeErrorZ_clone(uint64_t orig) {
13485 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(orig);
13486 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13487 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
13488 return tag_ptr(ret_conv, true);
13491 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_ok"))) TS_CResult_RouteParametersDecodeErrorZ_ok(uint64_t o) {
13492 LDKRouteParameters o_conv;
13493 o_conv.inner = untag_ptr(o);
13494 o_conv.is_owned = ptr_is_owned(o);
13495 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13496 o_conv = RouteParameters_clone(&o_conv);
13497 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13498 *ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
13499 return tag_ptr(ret_conv, true);
13502 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_err"))) TS_CResult_RouteParametersDecodeErrorZ_err(uint64_t e) {
13503 void* e_ptr = untag_ptr(e);
13504 CHECK_ACCESS(e_ptr);
13505 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13506 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13507 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13508 *ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
13509 return tag_ptr(ret_conv, true);
13512 jboolean __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_is_ok"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint64_t o) {
13513 LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(o);
13514 jboolean ret_conv = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
13518 void __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_free"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint64_t _res) {
13519 if (!ptr_is_owned(_res)) return;
13520 void* _res_ptr = untag_ptr(_res);
13521 CHECK_ACCESS(_res_ptr);
13522 LDKCResult_RouteParametersDecodeErrorZ _res_conv = *(LDKCResult_RouteParametersDecodeErrorZ*)(_res_ptr);
13523 FREE(untag_ptr(_res));
13524 CResult_RouteParametersDecodeErrorZ_free(_res_conv);
13527 static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
13528 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13529 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
13530 return tag_ptr(ret_conv, true);
13532 int64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone_ptr"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
13533 LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(arg);
13534 int64_t ret_conv = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
13538 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint64_t orig) {
13539 LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(orig);
13540 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13541 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(orig_conv);
13542 return tag_ptr(ret_conv, true);
13545 void __attribute__((export_name("TS_CVec_u64Z_free"))) TS_CVec_u64Z_free(int64_tArray _res) {
13546 LDKCVec_u64Z _res_constr;
13547 _res_constr.datalen = _res->arr_len;
13548 if (_res_constr.datalen > 0)
13549 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
13551 _res_constr.data = NULL;
13552 int64_t* _res_vals = _res->elems;
13553 for (size_t i = 0; i < _res_constr.datalen; i++) {
13554 int64_t _res_conv_8 = _res_vals[i];
13555 _res_constr.data[i] = _res_conv_8;
13558 CVec_u64Z_free(_res_constr);
13561 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_ok(uint64_t o) {
13562 LDKPaymentParameters o_conv;
13563 o_conv.inner = untag_ptr(o);
13564 o_conv.is_owned = ptr_is_owned(o);
13565 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13566 o_conv = PaymentParameters_clone(&o_conv);
13567 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13568 *ret_conv = CResult_PaymentParametersDecodeErrorZ_ok(o_conv);
13569 return tag_ptr(ret_conv, true);
13572 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_err"))) TS_CResult_PaymentParametersDecodeErrorZ_err(uint64_t e) {
13573 void* e_ptr = untag_ptr(e);
13574 CHECK_ACCESS(e_ptr);
13575 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13576 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13577 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13578 *ret_conv = CResult_PaymentParametersDecodeErrorZ_err(e_conv);
13579 return tag_ptr(ret_conv, true);
13582 jboolean __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_is_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_is_ok(uint64_t o) {
13583 LDKCResult_PaymentParametersDecodeErrorZ* o_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(o);
13584 jboolean ret_conv = CResult_PaymentParametersDecodeErrorZ_is_ok(o_conv);
13588 void __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_free"))) TS_CResult_PaymentParametersDecodeErrorZ_free(uint64_t _res) {
13589 if (!ptr_is_owned(_res)) return;
13590 void* _res_ptr = untag_ptr(_res);
13591 CHECK_ACCESS(_res_ptr);
13592 LDKCResult_PaymentParametersDecodeErrorZ _res_conv = *(LDKCResult_PaymentParametersDecodeErrorZ*)(_res_ptr);
13593 FREE(untag_ptr(_res));
13594 CResult_PaymentParametersDecodeErrorZ_free(_res_conv);
13597 static inline uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg) {
13598 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13599 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(arg);
13600 return tag_ptr(ret_conv, true);
13602 int64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
13603 LDKCResult_PaymentParametersDecodeErrorZ* arg_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(arg);
13604 int64_t ret_conv = CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg_conv);
13608 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone"))) TS_CResult_PaymentParametersDecodeErrorZ_clone(uint64_t orig) {
13609 LDKCResult_PaymentParametersDecodeErrorZ* orig_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(orig);
13610 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13611 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(orig_conv);
13612 return tag_ptr(ret_conv, true);
13615 static inline uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg) {
13616 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
13617 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(arg);
13618 return tag_ptr(ret_conv, true);
13620 int64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(uint64_t arg) {
13621 LDKC2Tuple_BlindedPayInfoBlindedPathZ* arg_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(arg);
13622 int64_t ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg_conv);
13626 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(uint64_t orig) {
13627 LDKC2Tuple_BlindedPayInfoBlindedPathZ* orig_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(orig);
13628 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
13629 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig_conv);
13630 return tag_ptr(ret_conv, true);
13633 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_new"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(uint64_t a, uint64_t b) {
13634 LDKBlindedPayInfo a_conv;
13635 a_conv.inner = untag_ptr(a);
13636 a_conv.is_owned = ptr_is_owned(a);
13637 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
13638 a_conv = BlindedPayInfo_clone(&a_conv);
13639 LDKBlindedPath b_conv;
13640 b_conv.inner = untag_ptr(b);
13641 b_conv.is_owned = ptr_is_owned(b);
13642 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
13643 b_conv = BlindedPath_clone(&b_conv);
13644 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
13645 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_new(a_conv, b_conv);
13646 return tag_ptr(ret_conv, true);
13649 void __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_free"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(uint64_t _res) {
13650 if (!ptr_is_owned(_res)) return;
13651 void* _res_ptr = untag_ptr(_res);
13652 CHECK_ACCESS(_res_ptr);
13653 LDKC2Tuple_BlindedPayInfoBlindedPathZ _res_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(_res_ptr);
13654 FREE(untag_ptr(_res));
13655 C2Tuple_BlindedPayInfoBlindedPathZ_free(_res_conv);
13658 void __attribute__((export_name("TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free"))) TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(uint64_tArray _res) {
13659 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res_constr;
13660 _res_constr.datalen = _res->arr_len;
13661 if (_res_constr.datalen > 0)
13662 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
13664 _res_constr.data = NULL;
13665 uint64_t* _res_vals = _res->elems;
13666 for (size_t l = 0; l < _res_constr.datalen; l++) {
13667 uint64_t _res_conv_37 = _res_vals[l];
13668 void* _res_conv_37_ptr = untag_ptr(_res_conv_37);
13669 CHECK_ACCESS(_res_conv_37_ptr);
13670 LDKC2Tuple_BlindedPayInfoBlindedPathZ _res_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(_res_conv_37_ptr);
13671 FREE(untag_ptr(_res_conv_37));
13672 _res_constr.data[l] = _res_conv_37_conv;
13675 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res_constr);
13678 void __attribute__((export_name("TS_CVec_RouteHintZ_free"))) TS_CVec_RouteHintZ_free(uint64_tArray _res) {
13679 LDKCVec_RouteHintZ _res_constr;
13680 _res_constr.datalen = _res->arr_len;
13681 if (_res_constr.datalen > 0)
13682 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
13684 _res_constr.data = NULL;
13685 uint64_t* _res_vals = _res->elems;
13686 for (size_t l = 0; l < _res_constr.datalen; l++) {
13687 uint64_t _res_conv_11 = _res_vals[l];
13688 LDKRouteHint _res_conv_11_conv;
13689 _res_conv_11_conv.inner = untag_ptr(_res_conv_11);
13690 _res_conv_11_conv.is_owned = ptr_is_owned(_res_conv_11);
13691 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
13692 _res_constr.data[l] = _res_conv_11_conv;
13695 CVec_RouteHintZ_free(_res_constr);
13698 void __attribute__((export_name("TS_CVec_RouteHintHopZ_free"))) TS_CVec_RouteHintHopZ_free(uint64_tArray _res) {
13699 LDKCVec_RouteHintHopZ _res_constr;
13700 _res_constr.datalen = _res->arr_len;
13701 if (_res_constr.datalen > 0)
13702 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
13704 _res_constr.data = NULL;
13705 uint64_t* _res_vals = _res->elems;
13706 for (size_t o = 0; o < _res_constr.datalen; o++) {
13707 uint64_t _res_conv_14 = _res_vals[o];
13708 LDKRouteHintHop _res_conv_14_conv;
13709 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
13710 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
13711 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
13712 _res_constr.data[o] = _res_conv_14_conv;
13715 CVec_RouteHintHopZ_free(_res_constr);
13718 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_ok"))) TS_CResult_RouteHintDecodeErrorZ_ok(uint64_t o) {
13719 LDKRouteHint o_conv;
13720 o_conv.inner = untag_ptr(o);
13721 o_conv.is_owned = ptr_is_owned(o);
13722 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13723 o_conv = RouteHint_clone(&o_conv);
13724 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13725 *ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
13726 return tag_ptr(ret_conv, true);
13729 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_err"))) TS_CResult_RouteHintDecodeErrorZ_err(uint64_t e) {
13730 void* e_ptr = untag_ptr(e);
13731 CHECK_ACCESS(e_ptr);
13732 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13733 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13734 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13735 *ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
13736 return tag_ptr(ret_conv, true);
13739 jboolean __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_is_ok"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint64_t o) {
13740 LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(o);
13741 jboolean ret_conv = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
13745 void __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_free"))) TS_CResult_RouteHintDecodeErrorZ_free(uint64_t _res) {
13746 if (!ptr_is_owned(_res)) return;
13747 void* _res_ptr = untag_ptr(_res);
13748 CHECK_ACCESS(_res_ptr);
13749 LDKCResult_RouteHintDecodeErrorZ _res_conv = *(LDKCResult_RouteHintDecodeErrorZ*)(_res_ptr);
13750 FREE(untag_ptr(_res));
13751 CResult_RouteHintDecodeErrorZ_free(_res_conv);
13754 static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
13755 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13756 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
13757 return tag_ptr(ret_conv, true);
13759 int64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint64_t arg) {
13760 LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(arg);
13761 int64_t ret_conv = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
13765 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint64_t orig) {
13766 LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(orig);
13767 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13768 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(orig_conv);
13769 return tag_ptr(ret_conv, true);
13772 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_ok(uint64_t o) {
13773 LDKRouteHintHop o_conv;
13774 o_conv.inner = untag_ptr(o);
13775 o_conv.is_owned = ptr_is_owned(o);
13776 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13777 o_conv = RouteHintHop_clone(&o_conv);
13778 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13779 *ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
13780 return tag_ptr(ret_conv, true);
13783 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_err"))) TS_CResult_RouteHintHopDecodeErrorZ_err(uint64_t e) {
13784 void* e_ptr = untag_ptr(e);
13785 CHECK_ACCESS(e_ptr);
13786 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13787 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13788 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13789 *ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
13790 return tag_ptr(ret_conv, true);
13793 jboolean __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint64_t o) {
13794 LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(o);
13795 jboolean ret_conv = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
13799 void __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_free"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint64_t _res) {
13800 if (!ptr_is_owned(_res)) return;
13801 void* _res_ptr = untag_ptr(_res);
13802 CHECK_ACCESS(_res_ptr);
13803 LDKCResult_RouteHintHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHintHopDecodeErrorZ*)(_res_ptr);
13804 FREE(untag_ptr(_res));
13805 CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
13808 static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
13809 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13810 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
13811 return tag_ptr(ret_conv, true);
13813 int64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint64_t arg) {
13814 LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(arg);
13815 int64_t ret_conv = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
13819 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint64_t orig) {
13820 LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(orig);
13821 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13822 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(orig_conv);
13823 return tag_ptr(ret_conv, true);
13826 void __attribute__((export_name("TS_CVec_PublicKeyZ_free"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
13827 LDKCVec_PublicKeyZ _res_constr;
13828 _res_constr.datalen = _res->arr_len;
13829 if (_res_constr.datalen > 0)
13830 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
13832 _res_constr.data = NULL;
13833 int8_tArray* _res_vals = (void*) _res->elems;
13834 for (size_t m = 0; m < _res_constr.datalen; m++) {
13835 int8_tArray _res_conv_12 = _res_vals[m];
13836 LDKPublicKey _res_conv_12_ref;
13837 CHECK(_res_conv_12->arr_len == 33);
13838 memcpy(_res_conv_12_ref.compressed_form, _res_conv_12->elems, 33); FREE(_res_conv_12);
13839 _res_constr.data[m] = _res_conv_12_ref;
13842 CVec_PublicKeyZ_free(_res_constr);
13845 static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
13846 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13847 *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
13848 return tag_ptr(ret_conv, true);
13850 int64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone_ptr"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint64_t arg) {
13851 LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(arg);
13852 int64_t ret_conv = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
13856 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone"))) TS_C2Tuple_usizeTransactionZ_clone(uint64_t orig) {
13857 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(orig);
13858 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13859 *ret_conv = C2Tuple_usizeTransactionZ_clone(orig_conv);
13860 return tag_ptr(ret_conv, true);
13863 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_new"))) TS_C2Tuple_usizeTransactionZ_new(uint32_t a, int8_tArray b) {
13864 LDKTransaction b_ref;
13865 b_ref.datalen = b->arr_len;
13866 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
13867 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
13868 b_ref.data_is_owned = true;
13869 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13870 *ret_conv = C2Tuple_usizeTransactionZ_new(a, b_ref);
13871 return tag_ptr(ret_conv, true);
13874 void __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_free"))) TS_C2Tuple_usizeTransactionZ_free(uint64_t _res) {
13875 if (!ptr_is_owned(_res)) return;
13876 void* _res_ptr = untag_ptr(_res);
13877 CHECK_ACCESS(_res_ptr);
13878 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_ptr);
13879 FREE(untag_ptr(_res));
13880 C2Tuple_usizeTransactionZ_free(_res_conv);
13883 void __attribute__((export_name("TS_CVec_C2Tuple_usizeTransactionZZ_free"))) TS_CVec_C2Tuple_usizeTransactionZZ_free(uint64_tArray _res) {
13884 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
13885 _res_constr.datalen = _res->arr_len;
13886 if (_res_constr.datalen > 0)
13887 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
13889 _res_constr.data = NULL;
13890 uint64_t* _res_vals = _res->elems;
13891 for (size_t c = 0; c < _res_constr.datalen; c++) {
13892 uint64_t _res_conv_28 = _res_vals[c];
13893 void* _res_conv_28_ptr = untag_ptr(_res_conv_28);
13894 CHECK_ACCESS(_res_conv_28_ptr);
13895 LDKC2Tuple_usizeTransactionZ _res_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_conv_28_ptr);
13896 FREE(untag_ptr(_res_conv_28));
13897 _res_constr.data[c] = _res_conv_28_conv;
13900 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
13903 static inline uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg) {
13904 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13905 *ret_conv = C2Tuple_TxidBlockHashZ_clone(arg);
13906 return tag_ptr(ret_conv, true);
13908 int64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_clone_ptr"))) TS_C2Tuple_TxidBlockHashZ_clone_ptr(uint64_t arg) {
13909 LDKC2Tuple_TxidBlockHashZ* arg_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(arg);
13910 int64_t ret_conv = C2Tuple_TxidBlockHashZ_clone_ptr(arg_conv);
13914 uint64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_clone"))) TS_C2Tuple_TxidBlockHashZ_clone(uint64_t orig) {
13915 LDKC2Tuple_TxidBlockHashZ* orig_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(orig);
13916 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13917 *ret_conv = C2Tuple_TxidBlockHashZ_clone(orig_conv);
13918 return tag_ptr(ret_conv, true);
13921 uint64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_new"))) TS_C2Tuple_TxidBlockHashZ_new(int8_tArray a, int8_tArray b) {
13922 LDKThirtyTwoBytes a_ref;
13923 CHECK(a->arr_len == 32);
13924 memcpy(a_ref.data, a->elems, 32); FREE(a);
13925 LDKThirtyTwoBytes b_ref;
13926 CHECK(b->arr_len == 32);
13927 memcpy(b_ref.data, b->elems, 32); FREE(b);
13928 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13929 *ret_conv = C2Tuple_TxidBlockHashZ_new(a_ref, b_ref);
13930 return tag_ptr(ret_conv, true);
13933 void __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_free"))) TS_C2Tuple_TxidBlockHashZ_free(uint64_t _res) {
13934 if (!ptr_is_owned(_res)) return;
13935 void* _res_ptr = untag_ptr(_res);
13936 CHECK_ACCESS(_res_ptr);
13937 LDKC2Tuple_TxidBlockHashZ _res_conv = *(LDKC2Tuple_TxidBlockHashZ*)(_res_ptr);
13938 FREE(untag_ptr(_res));
13939 C2Tuple_TxidBlockHashZ_free(_res_conv);
13942 void __attribute__((export_name("TS_CVec_C2Tuple_TxidBlockHashZZ_free"))) TS_CVec_C2Tuple_TxidBlockHashZZ_free(uint64_tArray _res) {
13943 LDKCVec_C2Tuple_TxidBlockHashZZ _res_constr;
13944 _res_constr.datalen = _res->arr_len;
13945 if (_res_constr.datalen > 0)
13946 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKCVec_C2Tuple_TxidBlockHashZZ Elements");
13948 _res_constr.data = NULL;
13949 uint64_t* _res_vals = _res->elems;
13950 for (size_t z = 0; z < _res_constr.datalen; z++) {
13951 uint64_t _res_conv_25 = _res_vals[z];
13952 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
13953 CHECK_ACCESS(_res_conv_25_ptr);
13954 LDKC2Tuple_TxidBlockHashZ _res_conv_25_conv = *(LDKC2Tuple_TxidBlockHashZ*)(_res_conv_25_ptr);
13955 FREE(untag_ptr(_res_conv_25));
13956 _res_constr.data[z] = _res_conv_25_conv;
13959 CVec_C2Tuple_TxidBlockHashZZ_free(_res_constr);
13962 void __attribute__((export_name("TS_CVec_MonitorEventZ_free"))) TS_CVec_MonitorEventZ_free(uint64_tArray _res) {
13963 LDKCVec_MonitorEventZ _res_constr;
13964 _res_constr.datalen = _res->arr_len;
13965 if (_res_constr.datalen > 0)
13966 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
13968 _res_constr.data = NULL;
13969 uint64_t* _res_vals = _res->elems;
13970 for (size_t o = 0; o < _res_constr.datalen; o++) {
13971 uint64_t _res_conv_14 = _res_vals[o];
13972 void* _res_conv_14_ptr = untag_ptr(_res_conv_14);
13973 CHECK_ACCESS(_res_conv_14_ptr);
13974 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(_res_conv_14_ptr);
13975 FREE(untag_ptr(_res_conv_14));
13976 _res_constr.data[o] = _res_conv_14_conv;
13979 CVec_MonitorEventZ_free(_res_constr);
13982 static inline uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg) {
13983 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13984 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(arg);
13985 return tag_ptr(ret_conv, true);
13987 int64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(uint64_t arg) {
13988 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* arg_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(arg);
13989 int64_t ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg_conv);
13993 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(uint64_t orig) {
13994 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* orig_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(orig);
13995 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13996 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig_conv);
13997 return tag_ptr(ret_conv, true);
14000 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(uint64_t a, uint64_tArray b, int8_tArray c) {
14001 LDKOutPoint a_conv;
14002 a_conv.inner = untag_ptr(a);
14003 a_conv.is_owned = ptr_is_owned(a);
14004 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
14005 a_conv = OutPoint_clone(&a_conv);
14006 LDKCVec_MonitorEventZ b_constr;
14007 b_constr.datalen = b->arr_len;
14008 if (b_constr.datalen > 0)
14009 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
14011 b_constr.data = NULL;
14012 uint64_t* b_vals = b->elems;
14013 for (size_t o = 0; o < b_constr.datalen; o++) {
14014 uint64_t b_conv_14 = b_vals[o];
14015 void* b_conv_14_ptr = untag_ptr(b_conv_14);
14016 CHECK_ACCESS(b_conv_14_ptr);
14017 LDKMonitorEvent b_conv_14_conv = *(LDKMonitorEvent*)(b_conv_14_ptr);
14018 b_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(b_conv_14));
14019 b_constr.data[o] = b_conv_14_conv;
14022 LDKPublicKey c_ref;
14023 CHECK(c->arr_len == 33);
14024 memcpy(c_ref.compressed_form, c->elems, 33); FREE(c);
14025 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
14026 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a_conv, b_constr, c_ref);
14027 return tag_ptr(ret_conv, true);
14030 void __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(uint64_t _res) {
14031 if (!ptr_is_owned(_res)) return;
14032 void* _res_ptr = untag_ptr(_res);
14033 CHECK_ACCESS(_res_ptr);
14034 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_ptr);
14035 FREE(untag_ptr(_res));
14036 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res_conv);
14039 void __attribute__((export_name("TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free"))) TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(uint64_tArray _res) {
14040 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res_constr;
14041 _res_constr.datalen = _res->arr_len;
14042 if (_res_constr.datalen > 0)
14043 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
14045 _res_constr.data = NULL;
14046 uint64_t* _res_vals = _res->elems;
14047 for (size_t x = 0; x < _res_constr.datalen; x++) {
14048 uint64_t _res_conv_49 = _res_vals[x];
14049 void* _res_conv_49_ptr = untag_ptr(_res_conv_49);
14050 CHECK_ACCESS(_res_conv_49_ptr);
14051 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_conv_49_ptr);
14052 FREE(untag_ptr(_res_conv_49));
14053 _res_constr.data[x] = _res_conv_49_conv;
14056 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res_constr);
14059 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(uint64_t o) {
14060 LDKFixedPenaltyScorer o_conv;
14061 o_conv.inner = untag_ptr(o);
14062 o_conv.is_owned = ptr_is_owned(o);
14063 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14064 o_conv = FixedPenaltyScorer_clone(&o_conv);
14065 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14066 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_ok(o_conv);
14067 return tag_ptr(ret_conv, true);
14070 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(uint64_t e) {
14071 void* e_ptr = untag_ptr(e);
14072 CHECK_ACCESS(e_ptr);
14073 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14074 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14075 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14076 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_err(e_conv);
14077 return tag_ptr(ret_conv, true);
14080 jboolean __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(uint64_t o) {
14081 LDKCResult_FixedPenaltyScorerDecodeErrorZ* o_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(o);
14082 jboolean ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o_conv);
14086 void __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_free"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(uint64_t _res) {
14087 if (!ptr_is_owned(_res)) return;
14088 void* _res_ptr = untag_ptr(_res);
14089 CHECK_ACCESS(_res_ptr);
14090 LDKCResult_FixedPenaltyScorerDecodeErrorZ _res_conv = *(LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(_res_ptr);
14091 FREE(untag_ptr(_res));
14092 CResult_FixedPenaltyScorerDecodeErrorZ_free(_res_conv);
14095 static inline uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg) {
14096 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14097 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(arg);
14098 return tag_ptr(ret_conv, true);
14100 int64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(uint64_t arg) {
14101 LDKCResult_FixedPenaltyScorerDecodeErrorZ* arg_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(arg);
14102 int64_t ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg_conv);
14106 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(uint64_t orig) {
14107 LDKCResult_FixedPenaltyScorerDecodeErrorZ* orig_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(orig);
14108 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14109 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig_conv);
14110 return tag_ptr(ret_conv, true);
14113 static inline uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg) {
14114 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14115 *ret_conv = C2Tuple_u64u64Z_clone(arg);
14116 return tag_ptr(ret_conv, true);
14118 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone_ptr"))) TS_C2Tuple_u64u64Z_clone_ptr(uint64_t arg) {
14119 LDKC2Tuple_u64u64Z* arg_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(arg);
14120 int64_t ret_conv = C2Tuple_u64u64Z_clone_ptr(arg_conv);
14124 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone"))) TS_C2Tuple_u64u64Z_clone(uint64_t orig) {
14125 LDKC2Tuple_u64u64Z* orig_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(orig);
14126 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14127 *ret_conv = C2Tuple_u64u64Z_clone(orig_conv);
14128 return tag_ptr(ret_conv, true);
14131 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_new"))) TS_C2Tuple_u64u64Z_new(int64_t a, int64_t b) {
14132 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14133 *ret_conv = C2Tuple_u64u64Z_new(a, b);
14134 return tag_ptr(ret_conv, true);
14137 void __attribute__((export_name("TS_C2Tuple_u64u64Z_free"))) TS_C2Tuple_u64u64Z_free(uint64_t _res) {
14138 if (!ptr_is_owned(_res)) return;
14139 void* _res_ptr = untag_ptr(_res);
14140 CHECK_ACCESS(_res_ptr);
14141 LDKC2Tuple_u64u64Z _res_conv = *(LDKC2Tuple_u64u64Z*)(_res_ptr);
14142 FREE(untag_ptr(_res));
14143 C2Tuple_u64u64Z_free(_res_conv);
14146 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_some"))) TS_COption_C2Tuple_u64u64ZZ_some(uint64_t o) {
14147 void* o_ptr = untag_ptr(o);
14148 CHECK_ACCESS(o_ptr);
14149 LDKC2Tuple_u64u64Z o_conv = *(LDKC2Tuple_u64u64Z*)(o_ptr);
14150 o_conv = C2Tuple_u64u64Z_clone((LDKC2Tuple_u64u64Z*)untag_ptr(o));
14151 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14152 *ret_copy = COption_C2Tuple_u64u64ZZ_some(o_conv);
14153 uint64_t ret_ref = tag_ptr(ret_copy, true);
14157 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_none"))) TS_COption_C2Tuple_u64u64ZZ_none() {
14158 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14159 *ret_copy = COption_C2Tuple_u64u64ZZ_none();
14160 uint64_t ret_ref = tag_ptr(ret_copy, true);
14164 void __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_free"))) TS_COption_C2Tuple_u64u64ZZ_free(uint64_t _res) {
14165 if (!ptr_is_owned(_res)) return;
14166 void* _res_ptr = untag_ptr(_res);
14167 CHECK_ACCESS(_res_ptr);
14168 LDKCOption_C2Tuple_u64u64ZZ _res_conv = *(LDKCOption_C2Tuple_u64u64ZZ*)(_res_ptr);
14169 FREE(untag_ptr(_res));
14170 COption_C2Tuple_u64u64ZZ_free(_res_conv);
14173 static inline uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg) {
14174 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14175 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(arg);
14176 uint64_t ret_ref = tag_ptr(ret_copy, true);
14179 int64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone_ptr"))) TS_COption_C2Tuple_u64u64ZZ_clone_ptr(uint64_t arg) {
14180 LDKCOption_C2Tuple_u64u64ZZ* arg_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(arg);
14181 int64_t ret_conv = COption_C2Tuple_u64u64ZZ_clone_ptr(arg_conv);
14185 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone"))) TS_COption_C2Tuple_u64u64ZZ_clone(uint64_t orig) {
14186 LDKCOption_C2Tuple_u64u64ZZ* orig_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(orig);
14187 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14188 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(orig_conv);
14189 uint64_t ret_ref = tag_ptr(ret_copy, true);
14193 static inline uint64_t C2Tuple_Z_clone_ptr(LDKC2Tuple_Z *NONNULL_PTR arg) {
14194 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
14195 *ret_conv = C2Tuple_Z_clone(arg);
14196 return tag_ptr(ret_conv, true);
14198 int64_t __attribute__((export_name("TS_C2Tuple_Z_clone_ptr"))) TS_C2Tuple_Z_clone_ptr(uint64_t arg) {
14199 LDKC2Tuple_Z* arg_conv = (LDKC2Tuple_Z*)untag_ptr(arg);
14200 int64_t ret_conv = C2Tuple_Z_clone_ptr(arg_conv);
14204 uint64_t __attribute__((export_name("TS_C2Tuple_Z_clone"))) TS_C2Tuple_Z_clone(uint64_t orig) {
14205 LDKC2Tuple_Z* orig_conv = (LDKC2Tuple_Z*)untag_ptr(orig);
14206 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
14207 *ret_conv = C2Tuple_Z_clone(orig_conv);
14208 return tag_ptr(ret_conv, true);
14211 uint64_t __attribute__((export_name("TS_C2Tuple_Z_new"))) TS_C2Tuple_Z_new(int16_tArray a, int16_tArray b) {
14212 LDKEightU16s a_ref;
14213 CHECK(a->arr_len == 8);
14214 memcpy(a_ref.data, a->elems, 8 * 2); FREE(a);
14215 LDKEightU16s b_ref;
14216 CHECK(b->arr_len == 8);
14217 memcpy(b_ref.data, b->elems, 8 * 2); FREE(b);
14218 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
14219 *ret_conv = C2Tuple_Z_new(a_ref, b_ref);
14220 return tag_ptr(ret_conv, true);
14223 void __attribute__((export_name("TS_C2Tuple_Z_free"))) TS_C2Tuple_Z_free(uint64_t _res) {
14224 if (!ptr_is_owned(_res)) return;
14225 void* _res_ptr = untag_ptr(_res);
14226 CHECK_ACCESS(_res_ptr);
14227 LDKC2Tuple_Z _res_conv = *(LDKC2Tuple_Z*)(_res_ptr);
14228 FREE(untag_ptr(_res));
14229 C2Tuple_Z_free(_res_conv);
14232 static inline uint64_t C2Tuple__u168_u168Z_clone_ptr(LDKC2Tuple__u168_u168Z *NONNULL_PTR arg) {
14233 LDKC2Tuple__u168_u168Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
14234 *ret_conv = C2Tuple__u168_u168Z_clone(arg);
14235 return tag_ptr(ret_conv, true);
14237 int64_t __attribute__((export_name("TS_C2Tuple__u168_u168Z_clone_ptr"))) TS_C2Tuple__u168_u168Z_clone_ptr(uint64_t arg) {
14238 LDKC2Tuple__u168_u168Z* arg_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(arg);
14239 int64_t ret_conv = C2Tuple__u168_u168Z_clone_ptr(arg_conv);
14243 uint64_t __attribute__((export_name("TS_C2Tuple__u168_u168Z_clone"))) TS_C2Tuple__u168_u168Z_clone(uint64_t orig) {
14244 LDKC2Tuple__u168_u168Z* orig_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(orig);
14245 LDKC2Tuple__u168_u168Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
14246 *ret_conv = C2Tuple__u168_u168Z_clone(orig_conv);
14247 return tag_ptr(ret_conv, true);
14250 uint64_t __attribute__((export_name("TS_C2Tuple__u168_u168Z_new"))) TS_C2Tuple__u168_u168Z_new(int16_tArray a, int16_tArray b) {
14251 LDKEightU16s a_ref;
14252 CHECK(a->arr_len == 8);
14253 memcpy(a_ref.data, a->elems, 8 * 2); FREE(a);
14254 LDKEightU16s b_ref;
14255 CHECK(b->arr_len == 8);
14256 memcpy(b_ref.data, b->elems, 8 * 2); FREE(b);
14257 LDKC2Tuple__u168_u168Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
14258 *ret_conv = C2Tuple__u168_u168Z_new(a_ref, b_ref);
14259 return tag_ptr(ret_conv, true);
14262 void __attribute__((export_name("TS_C2Tuple__u168_u168Z_free"))) TS_C2Tuple__u168_u168Z_free(uint64_t _res) {
14263 if (!ptr_is_owned(_res)) return;
14264 void* _res_ptr = untag_ptr(_res);
14265 CHECK_ACCESS(_res_ptr);
14266 LDKC2Tuple__u168_u168Z _res_conv = *(LDKC2Tuple__u168_u168Z*)(_res_ptr);
14267 FREE(untag_ptr(_res));
14268 C2Tuple__u168_u168Z_free(_res_conv);
14271 uint64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_some"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_some(uint64_t o) {
14272 void* o_ptr = untag_ptr(o);
14273 CHECK_ACCESS(o_ptr);
14274 LDKC2Tuple__u168_u168Z o_conv = *(LDKC2Tuple__u168_u168Z*)(o_ptr);
14275 o_conv = C2Tuple__u168_u168Z_clone((LDKC2Tuple__u168_u168Z*)untag_ptr(o));
14276 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14277 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_some(o_conv);
14278 uint64_t ret_ref = tag_ptr(ret_copy, true);
14282 uint64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_none"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_none() {
14283 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14284 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_none();
14285 uint64_t ret_ref = tag_ptr(ret_copy, true);
14289 void __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_free"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_free(uint64_t _res) {
14290 if (!ptr_is_owned(_res)) return;
14291 void* _res_ptr = untag_ptr(_res);
14292 CHECK_ACCESS(_res_ptr);
14293 LDKCOption_C2Tuple_EightU16sEightU16sZZ _res_conv = *(LDKCOption_C2Tuple_EightU16sEightU16sZZ*)(_res_ptr);
14294 FREE(untag_ptr(_res));
14295 COption_C2Tuple_EightU16sEightU16sZZ_free(_res_conv);
14298 static inline uint64_t COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR arg) {
14299 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14300 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_clone(arg);
14301 uint64_t ret_ref = tag_ptr(ret_copy, true);
14304 int64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(uint64_t arg) {
14305 LDKCOption_C2Tuple_EightU16sEightU16sZZ* arg_conv = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(arg);
14306 int64_t ret_conv = COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg_conv);
14310 uint64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_clone"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_clone(uint64_t orig) {
14311 LDKCOption_C2Tuple_EightU16sEightU16sZZ* orig_conv = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(orig);
14312 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14313 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_clone(orig_conv);
14314 uint64_t ret_ref = tag_ptr(ret_copy, true);
14318 void __attribute__((export_name("TS_CVec_NodeIdZ_free"))) TS_CVec_NodeIdZ_free(uint64_tArray _res) {
14319 LDKCVec_NodeIdZ _res_constr;
14320 _res_constr.datalen = _res->arr_len;
14321 if (_res_constr.datalen > 0)
14322 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
14324 _res_constr.data = NULL;
14325 uint64_t* _res_vals = _res->elems;
14326 for (size_t i = 0; i < _res_constr.datalen; i++) {
14327 uint64_t _res_conv_8 = _res_vals[i];
14328 LDKNodeId _res_conv_8_conv;
14329 _res_conv_8_conv.inner = untag_ptr(_res_conv_8);
14330 _res_conv_8_conv.is_owned = ptr_is_owned(_res_conv_8);
14331 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_8_conv);
14332 _res_constr.data[i] = _res_conv_8_conv;
14335 CVec_NodeIdZ_free(_res_constr);
14338 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(uint64_t o) {
14339 LDKProbabilisticScorer o_conv;
14340 o_conv.inner = untag_ptr(o);
14341 o_conv.is_owned = ptr_is_owned(o);
14342 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14343 // WARNING: we need a move here but no clone is available for LDKProbabilisticScorer
14345 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
14346 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_ok(o_conv);
14347 return tag_ptr(ret_conv, true);
14350 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_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_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
14356 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_err(e_conv);
14357 return tag_ptr(ret_conv, true);
14360 jboolean __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(uint64_t o) {
14361 LDKCResult_ProbabilisticScorerDecodeErrorZ* o_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(o);
14362 jboolean ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o_conv);
14366 void __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_free"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_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_ProbabilisticScorerDecodeErrorZ _res_conv = *(LDKCResult_ProbabilisticScorerDecodeErrorZ*)(_res_ptr);
14371 FREE(untag_ptr(_res));
14372 CResult_ProbabilisticScorerDecodeErrorZ_free(_res_conv);
14375 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint64_t o) {
14376 LDKInitFeatures o_conv;
14377 o_conv.inner = untag_ptr(o);
14378 o_conv.is_owned = ptr_is_owned(o);
14379 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14380 o_conv = InitFeatures_clone(&o_conv);
14381 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14382 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
14383 return tag_ptr(ret_conv, true);
14386 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_err"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint64_t e) {
14387 void* e_ptr = untag_ptr(e);
14388 CHECK_ACCESS(e_ptr);
14389 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14390 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14391 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14392 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
14393 return tag_ptr(ret_conv, true);
14396 jboolean __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14397 LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(o);
14398 jboolean ret_conv = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
14402 void __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_free"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint64_t _res) {
14403 if (!ptr_is_owned(_res)) return;
14404 void* _res_ptr = untag_ptr(_res);
14405 CHECK_ACCESS(_res_ptr);
14406 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(_res_ptr);
14407 FREE(untag_ptr(_res));
14408 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
14411 static inline uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14412 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14413 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(arg);
14414 return tag_ptr(ret_conv, true);
14416 int64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14417 LDKCResult_InitFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(arg);
14418 int64_t ret_conv = CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14422 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone"))) TS_CResult_InitFeaturesDecodeErrorZ_clone(uint64_t orig) {
14423 LDKCResult_InitFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(orig);
14424 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14425 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(orig_conv);
14426 return tag_ptr(ret_conv, true);
14429 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint64_t o) {
14430 LDKChannelFeatures o_conv;
14431 o_conv.inner = untag_ptr(o);
14432 o_conv.is_owned = ptr_is_owned(o);
14433 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14434 o_conv = ChannelFeatures_clone(&o_conv);
14435 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14436 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
14437 return tag_ptr(ret_conv, true);
14440 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint64_t e) {
14441 void* e_ptr = untag_ptr(e);
14442 CHECK_ACCESS(e_ptr);
14443 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14444 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14445 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14446 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
14447 return tag_ptr(ret_conv, true);
14450 jboolean __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14451 LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(o);
14452 jboolean ret_conv = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
14456 void __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint64_t _res) {
14457 if (!ptr_is_owned(_res)) return;
14458 void* _res_ptr = untag_ptr(_res);
14459 CHECK_ACCESS(_res_ptr);
14460 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(_res_ptr);
14461 FREE(untag_ptr(_res));
14462 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
14465 static inline uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14466 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14467 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(arg);
14468 return tag_ptr(ret_conv, true);
14470 int64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14471 LDKCResult_ChannelFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(arg);
14472 int64_t ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14476 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone(uint64_t orig) {
14477 LDKCResult_ChannelFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(orig);
14478 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14479 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(orig_conv);
14480 return tag_ptr(ret_conv, true);
14483 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint64_t o) {
14484 LDKNodeFeatures o_conv;
14485 o_conv.inner = untag_ptr(o);
14486 o_conv.is_owned = ptr_is_owned(o);
14487 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14488 o_conv = NodeFeatures_clone(&o_conv);
14489 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14490 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
14491 return tag_ptr(ret_conv, true);
14494 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint64_t e) {
14495 void* e_ptr = untag_ptr(e);
14496 CHECK_ACCESS(e_ptr);
14497 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14498 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14499 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14500 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
14501 return tag_ptr(ret_conv, true);
14504 jboolean __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14505 LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(o);
14506 jboolean ret_conv = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
14510 void __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_free"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint64_t _res) {
14511 if (!ptr_is_owned(_res)) return;
14512 void* _res_ptr = untag_ptr(_res);
14513 CHECK_ACCESS(_res_ptr);
14514 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(_res_ptr);
14515 FREE(untag_ptr(_res));
14516 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
14519 static inline uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14520 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14521 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(arg);
14522 return tag_ptr(ret_conv, true);
14524 int64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14525 LDKCResult_NodeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(arg);
14526 int64_t ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14530 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone(uint64_t orig) {
14531 LDKCResult_NodeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(orig);
14532 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14533 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(orig_conv);
14534 return tag_ptr(ret_conv, true);
14537 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(uint64_t o) {
14538 LDKInvoiceFeatures o_conv;
14539 o_conv.inner = untag_ptr(o);
14540 o_conv.is_owned = ptr_is_owned(o);
14541 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14542 o_conv = InvoiceFeatures_clone(&o_conv);
14543 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14544 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
14545 return tag_ptr(ret_conv, true);
14548 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_err(uint64_t e) {
14549 void* e_ptr = untag_ptr(e);
14550 CHECK_ACCESS(e_ptr);
14551 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14552 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14553 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14554 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
14555 return tag_ptr(ret_conv, true);
14558 jboolean __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14559 LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(o);
14560 jboolean ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
14564 void __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_free"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint64_t _res) {
14565 if (!ptr_is_owned(_res)) return;
14566 void* _res_ptr = untag_ptr(_res);
14567 CHECK_ACCESS(_res_ptr);
14568 LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
14569 FREE(untag_ptr(_res));
14570 CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
14573 static inline uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14574 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14575 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(arg);
14576 return tag_ptr(ret_conv, true);
14578 int64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14579 LDKCResult_InvoiceFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(arg);
14580 int64_t ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14584 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(uint64_t orig) {
14585 LDKCResult_InvoiceFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(orig);
14586 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14587 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(orig_conv);
14588 return tag_ptr(ret_conv, true);
14591 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(uint64_t o) {
14592 LDKBlindedHopFeatures o_conv;
14593 o_conv.inner = untag_ptr(o);
14594 o_conv.is_owned = ptr_is_owned(o);
14595 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14596 o_conv = BlindedHopFeatures_clone(&o_conv);
14597 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14598 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_ok(o_conv);
14599 return tag_ptr(ret_conv, true);
14602 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_err"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(uint64_t e) {
14603 void* e_ptr = untag_ptr(e);
14604 CHECK_ACCESS(e_ptr);
14605 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14606 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14607 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14608 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_err(e_conv);
14609 return tag_ptr(ret_conv, true);
14612 jboolean __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14613 LDKCResult_BlindedHopFeaturesDecodeErrorZ* o_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(o);
14614 jboolean ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o_conv);
14618 void __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_free"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(uint64_t _res) {
14619 if (!ptr_is_owned(_res)) return;
14620 void* _res_ptr = untag_ptr(_res);
14621 CHECK_ACCESS(_res_ptr);
14622 LDKCResult_BlindedHopFeaturesDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopFeaturesDecodeErrorZ*)(_res_ptr);
14623 FREE(untag_ptr(_res));
14624 CResult_BlindedHopFeaturesDecodeErrorZ_free(_res_conv);
14627 static inline uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14628 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14629 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone(arg);
14630 return tag_ptr(ret_conv, true);
14632 int64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14633 LDKCResult_BlindedHopFeaturesDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(arg);
14634 int64_t ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14638 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(uint64_t orig) {
14639 LDKCResult_BlindedHopFeaturesDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(orig);
14640 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14641 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig_conv);
14642 return tag_ptr(ret_conv, true);
14645 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(uint64_t o) {
14646 LDKChannelTypeFeatures o_conv;
14647 o_conv.inner = untag_ptr(o);
14648 o_conv.is_owned = ptr_is_owned(o);
14649 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14650 o_conv = ChannelTypeFeatures_clone(&o_conv);
14651 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14652 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o_conv);
14653 return tag_ptr(ret_conv, true);
14656 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(uint64_t e) {
14657 void* e_ptr = untag_ptr(e);
14658 CHECK_ACCESS(e_ptr);
14659 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14660 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14661 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14662 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_err(e_conv);
14663 return tag_ptr(ret_conv, true);
14666 jboolean __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14667 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(o);
14668 jboolean ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o_conv);
14672 void __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(uint64_t _res) {
14673 if (!ptr_is_owned(_res)) return;
14674 void* _res_ptr = untag_ptr(_res);
14675 CHECK_ACCESS(_res_ptr);
14676 LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(_res_ptr);
14677 FREE(untag_ptr(_res));
14678 CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res_conv);
14681 static inline uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14682 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14683 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(arg);
14684 return tag_ptr(ret_conv, true);
14686 int64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14687 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(arg);
14688 int64_t ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14692 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(uint64_t orig) {
14693 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(orig);
14694 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14695 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig_conv);
14696 return tag_ptr(ret_conv, true);
14699 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_ok(uint64_t o) {
14700 void* o_ptr = untag_ptr(o);
14701 CHECK_ACCESS(o_ptr);
14702 LDKPaymentPurpose o_conv = *(LDKPaymentPurpose*)(o_ptr);
14703 o_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(o));
14704 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14705 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_ok(o_conv);
14706 return tag_ptr(ret_conv, true);
14709 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_err(uint64_t e) {
14710 void* e_ptr = untag_ptr(e);
14711 CHECK_ACCESS(e_ptr);
14712 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14713 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14714 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14715 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_err(e_conv);
14716 return tag_ptr(ret_conv, true);
14719 jboolean __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_is_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(uint64_t o) {
14720 LDKCResult_PaymentPurposeDecodeErrorZ* o_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(o);
14721 jboolean ret_conv = CResult_PaymentPurposeDecodeErrorZ_is_ok(o_conv);
14725 void __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_free"))) TS_CResult_PaymentPurposeDecodeErrorZ_free(uint64_t _res) {
14726 if (!ptr_is_owned(_res)) return;
14727 void* _res_ptr = untag_ptr(_res);
14728 CHECK_ACCESS(_res_ptr);
14729 LDKCResult_PaymentPurposeDecodeErrorZ _res_conv = *(LDKCResult_PaymentPurposeDecodeErrorZ*)(_res_ptr);
14730 FREE(untag_ptr(_res));
14731 CResult_PaymentPurposeDecodeErrorZ_free(_res_conv);
14734 static inline uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg) {
14735 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14736 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(arg);
14737 return tag_ptr(ret_conv, true);
14739 int64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(uint64_t arg) {
14740 LDKCResult_PaymentPurposeDecodeErrorZ* arg_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(arg);
14741 int64_t ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg_conv);
14745 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone(uint64_t orig) {
14746 LDKCResult_PaymentPurposeDecodeErrorZ* orig_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(orig);
14747 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14748 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(orig_conv);
14749 return tag_ptr(ret_conv, true);
14752 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_some"))) TS_COption_NetworkUpdateZ_some(uint64_t o) {
14753 void* o_ptr = untag_ptr(o);
14754 CHECK_ACCESS(o_ptr);
14755 LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(o_ptr);
14756 o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)untag_ptr(o));
14757 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14758 *ret_copy = COption_NetworkUpdateZ_some(o_conv);
14759 uint64_t ret_ref = tag_ptr(ret_copy, true);
14763 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_none"))) TS_COption_NetworkUpdateZ_none() {
14764 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14765 *ret_copy = COption_NetworkUpdateZ_none();
14766 uint64_t ret_ref = tag_ptr(ret_copy, true);
14770 void __attribute__((export_name("TS_COption_NetworkUpdateZ_free"))) TS_COption_NetworkUpdateZ_free(uint64_t _res) {
14771 if (!ptr_is_owned(_res)) return;
14772 void* _res_ptr = untag_ptr(_res);
14773 CHECK_ACCESS(_res_ptr);
14774 LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(_res_ptr);
14775 FREE(untag_ptr(_res));
14776 COption_NetworkUpdateZ_free(_res_conv);
14779 static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
14780 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14781 *ret_copy = COption_NetworkUpdateZ_clone(arg);
14782 uint64_t ret_ref = tag_ptr(ret_copy, true);
14785 int64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone_ptr"))) TS_COption_NetworkUpdateZ_clone_ptr(uint64_t arg) {
14786 LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(arg);
14787 int64_t ret_conv = COption_NetworkUpdateZ_clone_ptr(arg_conv);
14791 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone"))) TS_COption_NetworkUpdateZ_clone(uint64_t orig) {
14792 LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(orig);
14793 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14794 *ret_copy = COption_NetworkUpdateZ_clone(orig_conv);
14795 uint64_t ret_ref = tag_ptr(ret_copy, true);
14799 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_some"))) TS_COption_PathFailureZ_some(uint64_t o) {
14800 void* o_ptr = untag_ptr(o);
14801 CHECK_ACCESS(o_ptr);
14802 LDKPathFailure o_conv = *(LDKPathFailure*)(o_ptr);
14803 o_conv = PathFailure_clone((LDKPathFailure*)untag_ptr(o));
14804 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14805 *ret_copy = COption_PathFailureZ_some(o_conv);
14806 uint64_t ret_ref = tag_ptr(ret_copy, true);
14810 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_none"))) TS_COption_PathFailureZ_none() {
14811 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14812 *ret_copy = COption_PathFailureZ_none();
14813 uint64_t ret_ref = tag_ptr(ret_copy, true);
14817 void __attribute__((export_name("TS_COption_PathFailureZ_free"))) TS_COption_PathFailureZ_free(uint64_t _res) {
14818 if (!ptr_is_owned(_res)) return;
14819 void* _res_ptr = untag_ptr(_res);
14820 CHECK_ACCESS(_res_ptr);
14821 LDKCOption_PathFailureZ _res_conv = *(LDKCOption_PathFailureZ*)(_res_ptr);
14822 FREE(untag_ptr(_res));
14823 COption_PathFailureZ_free(_res_conv);
14826 static inline uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg) {
14827 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14828 *ret_copy = COption_PathFailureZ_clone(arg);
14829 uint64_t ret_ref = tag_ptr(ret_copy, true);
14832 int64_t __attribute__((export_name("TS_COption_PathFailureZ_clone_ptr"))) TS_COption_PathFailureZ_clone_ptr(uint64_t arg) {
14833 LDKCOption_PathFailureZ* arg_conv = (LDKCOption_PathFailureZ*)untag_ptr(arg);
14834 int64_t ret_conv = COption_PathFailureZ_clone_ptr(arg_conv);
14838 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_clone"))) TS_COption_PathFailureZ_clone(uint64_t orig) {
14839 LDKCOption_PathFailureZ* orig_conv = (LDKCOption_PathFailureZ*)untag_ptr(orig);
14840 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14841 *ret_copy = COption_PathFailureZ_clone(orig_conv);
14842 uint64_t ret_ref = tag_ptr(ret_copy, true);
14846 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_ok(uint64_t o) {
14847 void* o_ptr = untag_ptr(o);
14848 CHECK_ACCESS(o_ptr);
14849 LDKCOption_PathFailureZ o_conv = *(LDKCOption_PathFailureZ*)(o_ptr);
14850 o_conv = COption_PathFailureZ_clone((LDKCOption_PathFailureZ*)untag_ptr(o));
14851 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14852 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_ok(o_conv);
14853 return tag_ptr(ret_conv, true);
14856 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_err"))) TS_CResult_COption_PathFailureZDecodeErrorZ_err(uint64_t e) {
14857 void* e_ptr = untag_ptr(e);
14858 CHECK_ACCESS(e_ptr);
14859 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14860 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14861 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14862 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_err(e_conv);
14863 return tag_ptr(ret_conv, true);
14866 jboolean __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(uint64_t o) {
14867 LDKCResult_COption_PathFailureZDecodeErrorZ* o_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(o);
14868 jboolean ret_conv = CResult_COption_PathFailureZDecodeErrorZ_is_ok(o_conv);
14872 void __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_free"))) TS_CResult_COption_PathFailureZDecodeErrorZ_free(uint64_t _res) {
14873 if (!ptr_is_owned(_res)) return;
14874 void* _res_ptr = untag_ptr(_res);
14875 CHECK_ACCESS(_res_ptr);
14876 LDKCResult_COption_PathFailureZDecodeErrorZ _res_conv = *(LDKCResult_COption_PathFailureZDecodeErrorZ*)(_res_ptr);
14877 FREE(untag_ptr(_res));
14878 CResult_COption_PathFailureZDecodeErrorZ_free(_res_conv);
14881 static inline uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg) {
14882 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14883 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone(arg);
14884 return tag_ptr(ret_conv, true);
14886 int64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(uint64_t arg) {
14887 LDKCResult_COption_PathFailureZDecodeErrorZ* arg_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(arg);
14888 int64_t ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg_conv);
14892 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_clone"))) TS_CResult_COption_PathFailureZDecodeErrorZ_clone(uint64_t orig) {
14893 LDKCResult_COption_PathFailureZDecodeErrorZ* orig_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(orig);
14894 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14895 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone(orig_conv);
14896 return tag_ptr(ret_conv, true);
14899 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_some"))) TS_COption_ClosureReasonZ_some(uint64_t o) {
14900 void* o_ptr = untag_ptr(o);
14901 CHECK_ACCESS(o_ptr);
14902 LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
14903 o_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(o));
14904 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14905 *ret_copy = COption_ClosureReasonZ_some(o_conv);
14906 uint64_t ret_ref = tag_ptr(ret_copy, true);
14910 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_none"))) TS_COption_ClosureReasonZ_none() {
14911 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14912 *ret_copy = COption_ClosureReasonZ_none();
14913 uint64_t ret_ref = tag_ptr(ret_copy, true);
14917 void __attribute__((export_name("TS_COption_ClosureReasonZ_free"))) TS_COption_ClosureReasonZ_free(uint64_t _res) {
14918 if (!ptr_is_owned(_res)) return;
14919 void* _res_ptr = untag_ptr(_res);
14920 CHECK_ACCESS(_res_ptr);
14921 LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
14922 FREE(untag_ptr(_res));
14923 COption_ClosureReasonZ_free(_res_conv);
14926 static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
14927 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14928 *ret_copy = COption_ClosureReasonZ_clone(arg);
14929 uint64_t ret_ref = tag_ptr(ret_copy, true);
14932 int64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone_ptr"))) TS_COption_ClosureReasonZ_clone_ptr(uint64_t arg) {
14933 LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(arg);
14934 int64_t ret_conv = COption_ClosureReasonZ_clone_ptr(arg_conv);
14938 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone"))) TS_COption_ClosureReasonZ_clone(uint64_t orig) {
14939 LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(orig);
14940 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14941 *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
14942 uint64_t ret_ref = tag_ptr(ret_copy, true);
14946 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint64_t o) {
14947 void* o_ptr = untag_ptr(o);
14948 CHECK_ACCESS(o_ptr);
14949 LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
14950 o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)untag_ptr(o));
14951 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14952 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
14953 return tag_ptr(ret_conv, true);
14956 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint64_t e) {
14957 void* e_ptr = untag_ptr(e);
14958 CHECK_ACCESS(e_ptr);
14959 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14960 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14961 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14962 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
14963 return tag_ptr(ret_conv, true);
14966 jboolean __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint64_t o) {
14967 LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(o);
14968 jboolean ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
14972 void __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_free"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint64_t _res) {
14973 if (!ptr_is_owned(_res)) return;
14974 void* _res_ptr = untag_ptr(_res);
14975 CHECK_ACCESS(_res_ptr);
14976 LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
14977 FREE(untag_ptr(_res));
14978 CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
14981 static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
14982 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14983 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
14984 return tag_ptr(ret_conv, true);
14986 int64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint64_t arg) {
14987 LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(arg);
14988 int64_t ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
14992 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint64_t orig) {
14993 LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(orig);
14994 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14995 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
14996 return tag_ptr(ret_conv, true);
14999 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_some"))) TS_COption_HTLCDestinationZ_some(uint64_t o) {
15000 void* o_ptr = untag_ptr(o);
15001 CHECK_ACCESS(o_ptr);
15002 LDKHTLCDestination o_conv = *(LDKHTLCDestination*)(o_ptr);
15003 o_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(o));
15004 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15005 *ret_copy = COption_HTLCDestinationZ_some(o_conv);
15006 uint64_t ret_ref = tag_ptr(ret_copy, true);
15010 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_none"))) TS_COption_HTLCDestinationZ_none() {
15011 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15012 *ret_copy = COption_HTLCDestinationZ_none();
15013 uint64_t ret_ref = tag_ptr(ret_copy, true);
15017 void __attribute__((export_name("TS_COption_HTLCDestinationZ_free"))) TS_COption_HTLCDestinationZ_free(uint64_t _res) {
15018 if (!ptr_is_owned(_res)) return;
15019 void* _res_ptr = untag_ptr(_res);
15020 CHECK_ACCESS(_res_ptr);
15021 LDKCOption_HTLCDestinationZ _res_conv = *(LDKCOption_HTLCDestinationZ*)(_res_ptr);
15022 FREE(untag_ptr(_res));
15023 COption_HTLCDestinationZ_free(_res_conv);
15026 static inline uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg) {
15027 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15028 *ret_copy = COption_HTLCDestinationZ_clone(arg);
15029 uint64_t ret_ref = tag_ptr(ret_copy, true);
15032 int64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone_ptr"))) TS_COption_HTLCDestinationZ_clone_ptr(uint64_t arg) {
15033 LDKCOption_HTLCDestinationZ* arg_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(arg);
15034 int64_t ret_conv = COption_HTLCDestinationZ_clone_ptr(arg_conv);
15038 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone"))) TS_COption_HTLCDestinationZ_clone(uint64_t orig) {
15039 LDKCOption_HTLCDestinationZ* orig_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(orig);
15040 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15041 *ret_copy = COption_HTLCDestinationZ_clone(orig_conv);
15042 uint64_t ret_ref = tag_ptr(ret_copy, true);
15046 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(uint64_t o) {
15047 void* o_ptr = untag_ptr(o);
15048 CHECK_ACCESS(o_ptr);
15049 LDKCOption_HTLCDestinationZ o_conv = *(LDKCOption_HTLCDestinationZ*)(o_ptr);
15050 o_conv = COption_HTLCDestinationZ_clone((LDKCOption_HTLCDestinationZ*)untag_ptr(o));
15051 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15052 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o_conv);
15053 return tag_ptr(ret_conv, true);
15056 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(uint64_t e) {
15057 void* e_ptr = untag_ptr(e);
15058 CHECK_ACCESS(e_ptr);
15059 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15060 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15061 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15062 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_err(e_conv);
15063 return tag_ptr(ret_conv, true);
15066 jboolean __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(uint64_t o) {
15067 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* o_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(o);
15068 jboolean ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o_conv);
15072 void __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(uint64_t _res) {
15073 if (!ptr_is_owned(_res)) return;
15074 void* _res_ptr = untag_ptr(_res);
15075 CHECK_ACCESS(_res_ptr);
15076 LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res_conv = *(LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(_res_ptr);
15077 FREE(untag_ptr(_res));
15078 CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res_conv);
15081 static inline uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg) {
15082 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15083 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(arg);
15084 return tag_ptr(ret_conv, true);
15086 int64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(uint64_t arg) {
15087 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* arg_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(arg);
15088 int64_t ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg_conv);
15092 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(uint64_t orig) {
15093 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* orig_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(orig);
15094 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15095 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig_conv);
15096 return tag_ptr(ret_conv, true);
15099 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(uint32_t o) {
15100 LDKPaymentFailureReason o_conv = LDKPaymentFailureReason_from_js(o);
15101 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15102 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_ok(o_conv);
15103 return tag_ptr(ret_conv, true);
15106 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_err"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_err(uint64_t e) {
15107 void* e_ptr = untag_ptr(e);
15108 CHECK_ACCESS(e_ptr);
15109 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15110 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15111 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15112 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_err(e_conv);
15113 return tag_ptr(ret_conv, true);
15116 jboolean __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(uint64_t o) {
15117 LDKCResult_PaymentFailureReasonDecodeErrorZ* o_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(o);
15118 jboolean ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o_conv);
15122 void __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_free"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_free(uint64_t _res) {
15123 if (!ptr_is_owned(_res)) return;
15124 void* _res_ptr = untag_ptr(_res);
15125 CHECK_ACCESS(_res_ptr);
15126 LDKCResult_PaymentFailureReasonDecodeErrorZ _res_conv = *(LDKCResult_PaymentFailureReasonDecodeErrorZ*)(_res_ptr);
15127 FREE(untag_ptr(_res));
15128 CResult_PaymentFailureReasonDecodeErrorZ_free(_res_conv);
15131 static inline uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg) {
15132 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15133 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone(arg);
15134 return tag_ptr(ret_conv, true);
15136 int64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(uint64_t arg) {
15137 LDKCResult_PaymentFailureReasonDecodeErrorZ* arg_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(arg);
15138 int64_t ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg_conv);
15142 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_clone"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(uint64_t orig) {
15143 LDKCResult_PaymentFailureReasonDecodeErrorZ* orig_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(orig);
15144 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15145 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone(orig_conv);
15146 return tag_ptr(ret_conv, true);
15149 uint64_t __attribute__((export_name("TS_COption_u128Z_some"))) TS_COption_u128Z_some(int8_tArray o) {
15151 CHECK(o->arr_len == 16);
15152 memcpy(o_ref.le_bytes, o->elems, 16); FREE(o);
15153 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15154 *ret_copy = COption_u128Z_some(o_ref);
15155 uint64_t ret_ref = tag_ptr(ret_copy, true);
15159 uint64_t __attribute__((export_name("TS_COption_u128Z_none"))) TS_COption_u128Z_none() {
15160 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15161 *ret_copy = COption_u128Z_none();
15162 uint64_t ret_ref = tag_ptr(ret_copy, true);
15166 void __attribute__((export_name("TS_COption_u128Z_free"))) TS_COption_u128Z_free(uint64_t _res) {
15167 if (!ptr_is_owned(_res)) return;
15168 void* _res_ptr = untag_ptr(_res);
15169 CHECK_ACCESS(_res_ptr);
15170 LDKCOption_u128Z _res_conv = *(LDKCOption_u128Z*)(_res_ptr);
15171 FREE(untag_ptr(_res));
15172 COption_u128Z_free(_res_conv);
15175 static inline uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg) {
15176 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15177 *ret_copy = COption_u128Z_clone(arg);
15178 uint64_t ret_ref = tag_ptr(ret_copy, true);
15181 int64_t __attribute__((export_name("TS_COption_u128Z_clone_ptr"))) TS_COption_u128Z_clone_ptr(uint64_t arg) {
15182 LDKCOption_u128Z* arg_conv = (LDKCOption_u128Z*)untag_ptr(arg);
15183 int64_t ret_conv = COption_u128Z_clone_ptr(arg_conv);
15187 uint64_t __attribute__((export_name("TS_COption_u128Z_clone"))) TS_COption_u128Z_clone(uint64_t orig) {
15188 LDKCOption_u128Z* orig_conv = (LDKCOption_u128Z*)untag_ptr(orig);
15189 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15190 *ret_copy = COption_u128Z_clone(orig_conv);
15191 uint64_t ret_ref = tag_ptr(ret_copy, true);
15195 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_some"))) TS_COption_PaymentFailureReasonZ_some(uint32_t o) {
15196 LDKPaymentFailureReason o_conv = LDKPaymentFailureReason_from_js(o);
15197 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15198 *ret_copy = COption_PaymentFailureReasonZ_some(o_conv);
15199 uint64_t ret_ref = tag_ptr(ret_copy, true);
15203 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_none"))) TS_COption_PaymentFailureReasonZ_none() {
15204 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15205 *ret_copy = COption_PaymentFailureReasonZ_none();
15206 uint64_t ret_ref = tag_ptr(ret_copy, true);
15210 void __attribute__((export_name("TS_COption_PaymentFailureReasonZ_free"))) TS_COption_PaymentFailureReasonZ_free(uint64_t _res) {
15211 if (!ptr_is_owned(_res)) return;
15212 void* _res_ptr = untag_ptr(_res);
15213 CHECK_ACCESS(_res_ptr);
15214 LDKCOption_PaymentFailureReasonZ _res_conv = *(LDKCOption_PaymentFailureReasonZ*)(_res_ptr);
15215 FREE(untag_ptr(_res));
15216 COption_PaymentFailureReasonZ_free(_res_conv);
15219 static inline uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg) {
15220 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15221 *ret_copy = COption_PaymentFailureReasonZ_clone(arg);
15222 uint64_t ret_ref = tag_ptr(ret_copy, true);
15225 int64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_clone_ptr"))) TS_COption_PaymentFailureReasonZ_clone_ptr(uint64_t arg) {
15226 LDKCOption_PaymentFailureReasonZ* arg_conv = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(arg);
15227 int64_t ret_conv = COption_PaymentFailureReasonZ_clone_ptr(arg_conv);
15231 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_clone"))) TS_COption_PaymentFailureReasonZ_clone(uint64_t orig) {
15232 LDKCOption_PaymentFailureReasonZ* orig_conv = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(orig);
15233 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15234 *ret_copy = COption_PaymentFailureReasonZ_clone(orig_conv);
15235 uint64_t ret_ref = tag_ptr(ret_copy, true);
15239 void __attribute__((export_name("TS_CVec_SpendableOutputDescriptorZ_free"))) TS_CVec_SpendableOutputDescriptorZ_free(uint64_tArray _res) {
15240 LDKCVec_SpendableOutputDescriptorZ _res_constr;
15241 _res_constr.datalen = _res->arr_len;
15242 if (_res_constr.datalen > 0)
15243 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
15245 _res_constr.data = NULL;
15246 uint64_t* _res_vals = _res->elems;
15247 for (size_t b = 0; b < _res_constr.datalen; b++) {
15248 uint64_t _res_conv_27 = _res_vals[b];
15249 void* _res_conv_27_ptr = untag_ptr(_res_conv_27);
15250 CHECK_ACCESS(_res_conv_27_ptr);
15251 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(_res_conv_27_ptr);
15252 FREE(untag_ptr(_res_conv_27));
15253 _res_constr.data[b] = _res_conv_27_conv;
15256 CVec_SpendableOutputDescriptorZ_free(_res_constr);
15259 uint64_t __attribute__((export_name("TS_COption_EventZ_some"))) TS_COption_EventZ_some(uint64_t o) {
15260 void* o_ptr = untag_ptr(o);
15261 CHECK_ACCESS(o_ptr);
15262 LDKEvent o_conv = *(LDKEvent*)(o_ptr);
15263 o_conv = Event_clone((LDKEvent*)untag_ptr(o));
15264 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15265 *ret_copy = COption_EventZ_some(o_conv);
15266 uint64_t ret_ref = tag_ptr(ret_copy, true);
15270 uint64_t __attribute__((export_name("TS_COption_EventZ_none"))) TS_COption_EventZ_none() {
15271 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15272 *ret_copy = COption_EventZ_none();
15273 uint64_t ret_ref = tag_ptr(ret_copy, true);
15277 void __attribute__((export_name("TS_COption_EventZ_free"))) TS_COption_EventZ_free(uint64_t _res) {
15278 if (!ptr_is_owned(_res)) return;
15279 void* _res_ptr = untag_ptr(_res);
15280 CHECK_ACCESS(_res_ptr);
15281 LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
15282 FREE(untag_ptr(_res));
15283 COption_EventZ_free(_res_conv);
15286 static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
15287 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15288 *ret_copy = COption_EventZ_clone(arg);
15289 uint64_t ret_ref = tag_ptr(ret_copy, true);
15292 int64_t __attribute__((export_name("TS_COption_EventZ_clone_ptr"))) TS_COption_EventZ_clone_ptr(uint64_t arg) {
15293 LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)untag_ptr(arg);
15294 int64_t ret_conv = COption_EventZ_clone_ptr(arg_conv);
15298 uint64_t __attribute__((export_name("TS_COption_EventZ_clone"))) TS_COption_EventZ_clone(uint64_t orig) {
15299 LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)untag_ptr(orig);
15300 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15301 *ret_copy = COption_EventZ_clone(orig_conv);
15302 uint64_t ret_ref = tag_ptr(ret_copy, true);
15306 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_ok"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint64_t o) {
15307 void* o_ptr = untag_ptr(o);
15308 CHECK_ACCESS(o_ptr);
15309 LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
15310 o_conv = COption_EventZ_clone((LDKCOption_EventZ*)untag_ptr(o));
15311 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15312 *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
15313 return tag_ptr(ret_conv, true);
15316 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_err"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint64_t e) {
15317 void* e_ptr = untag_ptr(e);
15318 CHECK_ACCESS(e_ptr);
15319 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15320 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15321 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15322 *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
15323 return tag_ptr(ret_conv, true);
15326 jboolean __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_is_ok"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint64_t o) {
15327 LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(o);
15328 jboolean ret_conv = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
15332 void __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_free"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint64_t _res) {
15333 if (!ptr_is_owned(_res)) return;
15334 void* _res_ptr = untag_ptr(_res);
15335 CHECK_ACCESS(_res_ptr);
15336 LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
15337 FREE(untag_ptr(_res));
15338 CResult_COption_EventZDecodeErrorZ_free(_res_conv);
15341 static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
15342 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15343 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
15344 return tag_ptr(ret_conv, true);
15346 int64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint64_t arg) {
15347 LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(arg);
15348 int64_t ret_conv = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
15352 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint64_t orig) {
15353 LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(orig);
15354 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15355 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
15356 return tag_ptr(ret_conv, true);
15359 void __attribute__((export_name("TS_CVec_MessageSendEventZ_free"))) TS_CVec_MessageSendEventZ_free(uint64_tArray _res) {
15360 LDKCVec_MessageSendEventZ _res_constr;
15361 _res_constr.datalen = _res->arr_len;
15362 if (_res_constr.datalen > 0)
15363 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
15365 _res_constr.data = NULL;
15366 uint64_t* _res_vals = _res->elems;
15367 for (size_t s = 0; s < _res_constr.datalen; s++) {
15368 uint64_t _res_conv_18 = _res_vals[s];
15369 void* _res_conv_18_ptr = untag_ptr(_res_conv_18);
15370 CHECK_ACCESS(_res_conv_18_ptr);
15371 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(_res_conv_18_ptr);
15372 FREE(untag_ptr(_res_conv_18));
15373 _res_constr.data[s] = _res_conv_18_conv;
15376 CVec_MessageSendEventZ_free(_res_constr);
15379 void __attribute__((export_name("TS_CVec_ChainHashZ_free"))) TS_CVec_ChainHashZ_free(ptrArray _res) {
15380 LDKCVec_ChainHashZ _res_constr;
15381 _res_constr.datalen = _res->arr_len;
15382 if (_res_constr.datalen > 0)
15383 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ChainHashZ Elements");
15385 _res_constr.data = NULL;
15386 int8_tArray* _res_vals = (void*) _res->elems;
15387 for (size_t m = 0; m < _res_constr.datalen; m++) {
15388 int8_tArray _res_conv_12 = _res_vals[m];
15389 LDKThirtyTwoBytes _res_conv_12_ref;
15390 CHECK(_res_conv_12->arr_len == 32);
15391 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
15392 _res_constr.data[m] = _res_conv_12_ref;
15395 CVec_ChainHashZ_free(_res_constr);
15398 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_ok"))) TS_CResult_PublicKeyErrorZ_ok(int8_tArray o) {
15399 LDKPublicKey o_ref;
15400 CHECK(o->arr_len == 33);
15401 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
15402 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15403 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
15404 return tag_ptr(ret_conv, true);
15407 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_err"))) TS_CResult_PublicKeyErrorZ_err(uint32_t e) {
15408 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
15409 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15410 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
15411 return tag_ptr(ret_conv, true);
15414 jboolean __attribute__((export_name("TS_CResult_PublicKeyErrorZ_is_ok"))) TS_CResult_PublicKeyErrorZ_is_ok(uint64_t o) {
15415 LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(o);
15416 jboolean ret_conv = CResult_PublicKeyErrorZ_is_ok(o_conv);
15420 void __attribute__((export_name("TS_CResult_PublicKeyErrorZ_free"))) TS_CResult_PublicKeyErrorZ_free(uint64_t _res) {
15421 if (!ptr_is_owned(_res)) return;
15422 void* _res_ptr = untag_ptr(_res);
15423 CHECK_ACCESS(_res_ptr);
15424 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(_res_ptr);
15425 FREE(untag_ptr(_res));
15426 CResult_PublicKeyErrorZ_free(_res_conv);
15429 static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
15430 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15431 *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
15432 return tag_ptr(ret_conv, true);
15434 int64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone_ptr"))) TS_CResult_PublicKeyErrorZ_clone_ptr(uint64_t arg) {
15435 LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(arg);
15436 int64_t ret_conv = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
15440 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone"))) TS_CResult_PublicKeyErrorZ_clone(uint64_t orig) {
15441 LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(orig);
15442 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15443 *ret_conv = CResult_PublicKeyErrorZ_clone(orig_conv);
15444 return tag_ptr(ret_conv, true);
15447 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_ok"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint64_t o) {
15449 o_conv.inner = untag_ptr(o);
15450 o_conv.is_owned = ptr_is_owned(o);
15451 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15452 o_conv = NodeId_clone(&o_conv);
15453 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15454 *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
15455 return tag_ptr(ret_conv, true);
15458 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_err"))) TS_CResult_NodeIdDecodeErrorZ_err(uint64_t e) {
15459 void* e_ptr = untag_ptr(e);
15460 CHECK_ACCESS(e_ptr);
15461 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15462 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15463 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15464 *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
15465 return tag_ptr(ret_conv, true);
15468 jboolean __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_is_ok"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint64_t o) {
15469 LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(o);
15470 jboolean ret_conv = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
15474 void __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_free"))) TS_CResult_NodeIdDecodeErrorZ_free(uint64_t _res) {
15475 if (!ptr_is_owned(_res)) return;
15476 void* _res_ptr = untag_ptr(_res);
15477 CHECK_ACCESS(_res_ptr);
15478 LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
15479 FREE(untag_ptr(_res));
15480 CResult_NodeIdDecodeErrorZ_free(_res_conv);
15483 static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
15484 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15485 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
15486 return tag_ptr(ret_conv, true);
15488 int64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone_ptr"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint64_t arg) {
15489 LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(arg);
15490 int64_t ret_conv = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
15494 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint64_t orig) {
15495 LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(orig);
15496 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15497 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
15498 return tag_ptr(ret_conv, true);
15501 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint64_t o) {
15502 void* o_ptr = untag_ptr(o);
15503 CHECK_ACCESS(o_ptr);
15504 LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
15505 o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(o));
15506 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15507 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
15508 return tag_ptr(ret_conv, true);
15511 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint64_t e) {
15512 void* e_ptr = untag_ptr(e);
15513 CHECK_ACCESS(e_ptr);
15514 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15515 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15516 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15517 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
15518 return tag_ptr(ret_conv, true);
15521 jboolean __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint64_t o) {
15522 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(o);
15523 jboolean ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
15527 void __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint64_t _res) {
15528 if (!ptr_is_owned(_res)) return;
15529 void* _res_ptr = untag_ptr(_res);
15530 CHECK_ACCESS(_res_ptr);
15531 LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
15532 FREE(untag_ptr(_res));
15533 CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
15536 static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
15537 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15538 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
15539 return tag_ptr(ret_conv, true);
15541 int64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint64_t arg) {
15542 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(arg);
15543 int64_t ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
15547 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint64_t orig) {
15548 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(orig);
15549 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15550 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
15551 return tag_ptr(ret_conv, true);
15554 uint64_t __attribute__((export_name("TS_COption_UtxoLookupZ_some"))) TS_COption_UtxoLookupZ_some(uint64_t o) {
15555 void* o_ptr = untag_ptr(o);
15556 CHECK_ACCESS(o_ptr);
15557 LDKUtxoLookup o_conv = *(LDKUtxoLookup*)(o_ptr);
15558 if (o_conv.free == LDKUtxoLookup_JCalls_free) {
15559 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
15560 LDKUtxoLookup_JCalls_cloned(&o_conv);
15562 LDKCOption_UtxoLookupZ *ret_copy = MALLOC(sizeof(LDKCOption_UtxoLookupZ), "LDKCOption_UtxoLookupZ");
15563 *ret_copy = COption_UtxoLookupZ_some(o_conv);
15564 uint64_t ret_ref = tag_ptr(ret_copy, true);
15568 uint64_t __attribute__((export_name("TS_COption_UtxoLookupZ_none"))) TS_COption_UtxoLookupZ_none() {
15569 LDKCOption_UtxoLookupZ *ret_copy = MALLOC(sizeof(LDKCOption_UtxoLookupZ), "LDKCOption_UtxoLookupZ");
15570 *ret_copy = COption_UtxoLookupZ_none();
15571 uint64_t ret_ref = tag_ptr(ret_copy, true);
15575 void __attribute__((export_name("TS_COption_UtxoLookupZ_free"))) TS_COption_UtxoLookupZ_free(uint64_t _res) {
15576 if (!ptr_is_owned(_res)) return;
15577 void* _res_ptr = untag_ptr(_res);
15578 CHECK_ACCESS(_res_ptr);
15579 LDKCOption_UtxoLookupZ _res_conv = *(LDKCOption_UtxoLookupZ*)(_res_ptr);
15580 FREE(untag_ptr(_res));
15581 COption_UtxoLookupZ_free(_res_conv);
15584 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_ok"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
15585 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15586 *ret_conv = CResult_boolLightningErrorZ_ok(o);
15587 return tag_ptr(ret_conv, true);
15590 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_err"))) TS_CResult_boolLightningErrorZ_err(uint64_t e) {
15591 LDKLightningError e_conv;
15592 e_conv.inner = untag_ptr(e);
15593 e_conv.is_owned = ptr_is_owned(e);
15594 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15595 e_conv = LightningError_clone(&e_conv);
15596 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15597 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
15598 return tag_ptr(ret_conv, true);
15601 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_is_ok"))) TS_CResult_boolLightningErrorZ_is_ok(uint64_t o) {
15602 LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(o);
15603 jboolean ret_conv = CResult_boolLightningErrorZ_is_ok(o_conv);
15607 void __attribute__((export_name("TS_CResult_boolLightningErrorZ_free"))) TS_CResult_boolLightningErrorZ_free(uint64_t _res) {
15608 if (!ptr_is_owned(_res)) return;
15609 void* _res_ptr = untag_ptr(_res);
15610 CHECK_ACCESS(_res_ptr);
15611 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(_res_ptr);
15612 FREE(untag_ptr(_res));
15613 CResult_boolLightningErrorZ_free(_res_conv);
15616 static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
15617 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15618 *ret_conv = CResult_boolLightningErrorZ_clone(arg);
15619 return tag_ptr(ret_conv, true);
15621 int64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone_ptr"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint64_t arg) {
15622 LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(arg);
15623 int64_t ret_conv = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
15627 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone"))) TS_CResult_boolLightningErrorZ_clone(uint64_t orig) {
15628 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(orig);
15629 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15630 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
15631 return tag_ptr(ret_conv, true);
15634 static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
15635 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
15636 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
15637 return tag_ptr(ret_conv, true);
15639 int64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint64_t arg) {
15640 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(arg);
15641 int64_t ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
15645 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint64_t orig) {
15646 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(orig);
15647 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
15648 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
15649 return tag_ptr(ret_conv, true);
15652 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint64_t a, uint64_t b, uint64_t c) {
15653 LDKChannelAnnouncement a_conv;
15654 a_conv.inner = untag_ptr(a);
15655 a_conv.is_owned = ptr_is_owned(a);
15656 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
15657 a_conv = ChannelAnnouncement_clone(&a_conv);
15658 LDKChannelUpdate b_conv;
15659 b_conv.inner = untag_ptr(b);
15660 b_conv.is_owned = ptr_is_owned(b);
15661 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
15662 b_conv = ChannelUpdate_clone(&b_conv);
15663 LDKChannelUpdate c_conv;
15664 c_conv.inner = untag_ptr(c);
15665 c_conv.is_owned = ptr_is_owned(c);
15666 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
15667 c_conv = ChannelUpdate_clone(&c_conv);
15668 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
15669 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
15670 return tag_ptr(ret_conv, true);
15673 void __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint64_t _res) {
15674 if (!ptr_is_owned(_res)) return;
15675 void* _res_ptr = untag_ptr(_res);
15676 CHECK_ACCESS(_res_ptr);
15677 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_ptr);
15678 FREE(untag_ptr(_res));
15679 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
15682 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(uint64_t o) {
15683 void* o_ptr = untag_ptr(o);
15684 CHECK_ACCESS(o_ptr);
15685 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(o_ptr);
15686 o_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(o));
15687 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15688 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o_conv);
15689 uint64_t ret_ref = tag_ptr(ret_copy, true);
15693 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none() {
15694 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15695 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
15696 uint64_t ret_ref = tag_ptr(ret_copy, true);
15700 void __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint64_t _res) {
15701 if (!ptr_is_owned(_res)) return;
15702 void* _res_ptr = untag_ptr(_res);
15703 CHECK_ACCESS(_res_ptr);
15704 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(_res_ptr);
15705 FREE(untag_ptr(_res));
15706 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_conv);
15709 static inline uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg) {
15710 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15711 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(arg);
15712 uint64_t ret_ref = tag_ptr(ret_copy, true);
15715 int64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(uint64_t arg) {
15716 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* arg_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(arg);
15717 int64_t ret_conv = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg_conv);
15721 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(uint64_t orig) {
15722 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* orig_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(orig);
15723 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15724 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig_conv);
15725 uint64_t ret_ref = tag_ptr(ret_copy, true);
15729 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_ok"))) TS_CResult_NoneLightningErrorZ_ok() {
15730 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15731 *ret_conv = CResult_NoneLightningErrorZ_ok();
15732 return tag_ptr(ret_conv, true);
15735 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_err"))) TS_CResult_NoneLightningErrorZ_err(uint64_t e) {
15736 LDKLightningError e_conv;
15737 e_conv.inner = untag_ptr(e);
15738 e_conv.is_owned = ptr_is_owned(e);
15739 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15740 e_conv = LightningError_clone(&e_conv);
15741 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15742 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
15743 return tag_ptr(ret_conv, true);
15746 jboolean __attribute__((export_name("TS_CResult_NoneLightningErrorZ_is_ok"))) TS_CResult_NoneLightningErrorZ_is_ok(uint64_t o) {
15747 LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(o);
15748 jboolean ret_conv = CResult_NoneLightningErrorZ_is_ok(o_conv);
15752 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_free"))) TS_CResult_NoneLightningErrorZ_free(uint64_t _res) {
15753 if (!ptr_is_owned(_res)) return;
15754 void* _res_ptr = untag_ptr(_res);
15755 CHECK_ACCESS(_res_ptr);
15756 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(_res_ptr);
15757 FREE(untag_ptr(_res));
15758 CResult_NoneLightningErrorZ_free(_res_conv);
15761 static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
15762 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15763 *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
15764 return tag_ptr(ret_conv, true);
15766 int64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone_ptr"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint64_t arg) {
15767 LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(arg);
15768 int64_t ret_conv = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
15772 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone"))) TS_CResult_NoneLightningErrorZ_clone(uint64_t orig) {
15773 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(orig);
15774 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15775 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
15776 return tag_ptr(ret_conv, true);
15779 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(uint64_t o) {
15780 LDKChannelUpdateInfo o_conv;
15781 o_conv.inner = untag_ptr(o);
15782 o_conv.is_owned = ptr_is_owned(o);
15783 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15784 o_conv = ChannelUpdateInfo_clone(&o_conv);
15785 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15786 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_ok(o_conv);
15787 return tag_ptr(ret_conv, true);
15790 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(uint64_t e) {
15791 void* e_ptr = untag_ptr(e);
15792 CHECK_ACCESS(e_ptr);
15793 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15794 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15795 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15796 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_err(e_conv);
15797 return tag_ptr(ret_conv, true);
15800 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(uint64_t o) {
15801 LDKCResult_ChannelUpdateInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(o);
15802 jboolean ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o_conv);
15806 void __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_free"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(uint64_t _res) {
15807 if (!ptr_is_owned(_res)) return;
15808 void* _res_ptr = untag_ptr(_res);
15809 CHECK_ACCESS(_res_ptr);
15810 LDKCResult_ChannelUpdateInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(_res_ptr);
15811 FREE(untag_ptr(_res));
15812 CResult_ChannelUpdateInfoDecodeErrorZ_free(_res_conv);
15815 static inline uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg) {
15816 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15817 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(arg);
15818 return tag_ptr(ret_conv, true);
15820 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15821 LDKCResult_ChannelUpdateInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(arg);
15822 int64_t ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg_conv);
15826 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(uint64_t orig) {
15827 LDKCResult_ChannelUpdateInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(orig);
15828 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15829 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig_conv);
15830 return tag_ptr(ret_conv, true);
15833 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint64_t o) {
15834 LDKChannelInfo o_conv;
15835 o_conv.inner = untag_ptr(o);
15836 o_conv.is_owned = ptr_is_owned(o);
15837 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15838 o_conv = ChannelInfo_clone(&o_conv);
15839 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15840 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
15841 return tag_ptr(ret_conv, true);
15844 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_err"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint64_t e) {
15845 void* e_ptr = untag_ptr(e);
15846 CHECK_ACCESS(e_ptr);
15847 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15848 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15849 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15850 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
15851 return tag_ptr(ret_conv, true);
15854 jboolean __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint64_t o) {
15855 LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(o);
15856 jboolean ret_conv = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
15860 void __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_free"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint64_t _res) {
15861 if (!ptr_is_owned(_res)) return;
15862 void* _res_ptr = untag_ptr(_res);
15863 CHECK_ACCESS(_res_ptr);
15864 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(_res_ptr);
15865 FREE(untag_ptr(_res));
15866 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
15869 static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
15870 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15871 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
15872 return tag_ptr(ret_conv, true);
15874 int64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15875 LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(arg);
15876 int64_t ret_conv = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
15880 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint64_t orig) {
15881 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(orig);
15882 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15883 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
15884 return tag_ptr(ret_conv, true);
15887 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint64_t o) {
15888 LDKRoutingFees o_conv;
15889 o_conv.inner = untag_ptr(o);
15890 o_conv.is_owned = ptr_is_owned(o);
15891 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15892 o_conv = RoutingFees_clone(&o_conv);
15893 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15894 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
15895 return tag_ptr(ret_conv, true);
15898 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_err"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint64_t e) {
15899 void* e_ptr = untag_ptr(e);
15900 CHECK_ACCESS(e_ptr);
15901 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15902 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15903 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15904 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
15905 return tag_ptr(ret_conv, true);
15908 jboolean __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_is_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint64_t o) {
15909 LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(o);
15910 jboolean ret_conv = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
15914 void __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_free"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint64_t _res) {
15915 if (!ptr_is_owned(_res)) return;
15916 void* _res_ptr = untag_ptr(_res);
15917 CHECK_ACCESS(_res_ptr);
15918 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(_res_ptr);
15919 FREE(untag_ptr(_res));
15920 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
15923 static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
15924 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15925 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
15926 return tag_ptr(ret_conv, true);
15928 int64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint64_t arg) {
15929 LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(arg);
15930 int64_t ret_conv = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
15934 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint64_t orig) {
15935 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(orig);
15936 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15937 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
15938 return tag_ptr(ret_conv, true);
15941 void __attribute__((export_name("TS_CVec_NetAddressZ_free"))) TS_CVec_NetAddressZ_free(uint64_tArray _res) {
15942 LDKCVec_NetAddressZ _res_constr;
15943 _res_constr.datalen = _res->arr_len;
15944 if (_res_constr.datalen > 0)
15945 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
15947 _res_constr.data = NULL;
15948 uint64_t* _res_vals = _res->elems;
15949 for (size_t m = 0; m < _res_constr.datalen; m++) {
15950 uint64_t _res_conv_12 = _res_vals[m];
15951 void* _res_conv_12_ptr = untag_ptr(_res_conv_12);
15952 CHECK_ACCESS(_res_conv_12_ptr);
15953 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(_res_conv_12_ptr);
15954 FREE(untag_ptr(_res_conv_12));
15955 _res_constr.data[m] = _res_conv_12_conv;
15958 CVec_NetAddressZ_free(_res_constr);
15961 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint64_t o) {
15962 LDKNodeAnnouncementInfo o_conv;
15963 o_conv.inner = untag_ptr(o);
15964 o_conv.is_owned = ptr_is_owned(o);
15965 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15966 o_conv = NodeAnnouncementInfo_clone(&o_conv);
15967 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15968 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
15969 return tag_ptr(ret_conv, true);
15972 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint64_t e) {
15973 void* e_ptr = untag_ptr(e);
15974 CHECK_ACCESS(e_ptr);
15975 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15976 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15977 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15978 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
15979 return tag_ptr(ret_conv, true);
15982 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint64_t o) {
15983 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(o);
15984 jboolean ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
15988 void __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint64_t _res) {
15989 if (!ptr_is_owned(_res)) return;
15990 void* _res_ptr = untag_ptr(_res);
15991 CHECK_ACCESS(_res_ptr);
15992 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(_res_ptr);
15993 FREE(untag_ptr(_res));
15994 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
15997 static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
15998 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15999 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
16000 return tag_ptr(ret_conv, true);
16002 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
16003 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(arg);
16004 int64_t ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
16008 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint64_t orig) {
16009 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(orig);
16010 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
16011 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
16012 return tag_ptr(ret_conv, true);
16015 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_ok"))) TS_CResult_NodeAliasDecodeErrorZ_ok(uint64_t o) {
16016 LDKNodeAlias o_conv;
16017 o_conv.inner = untag_ptr(o);
16018 o_conv.is_owned = ptr_is_owned(o);
16019 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16020 o_conv = NodeAlias_clone(&o_conv);
16021 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16022 *ret_conv = CResult_NodeAliasDecodeErrorZ_ok(o_conv);
16023 return tag_ptr(ret_conv, true);
16026 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_err"))) TS_CResult_NodeAliasDecodeErrorZ_err(uint64_t e) {
16027 void* e_ptr = untag_ptr(e);
16028 CHECK_ACCESS(e_ptr);
16029 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16030 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16031 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16032 *ret_conv = CResult_NodeAliasDecodeErrorZ_err(e_conv);
16033 return tag_ptr(ret_conv, true);
16036 jboolean __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_is_ok"))) TS_CResult_NodeAliasDecodeErrorZ_is_ok(uint64_t o) {
16037 LDKCResult_NodeAliasDecodeErrorZ* o_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(o);
16038 jboolean ret_conv = CResult_NodeAliasDecodeErrorZ_is_ok(o_conv);
16042 void __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_free"))) TS_CResult_NodeAliasDecodeErrorZ_free(uint64_t _res) {
16043 if (!ptr_is_owned(_res)) return;
16044 void* _res_ptr = untag_ptr(_res);
16045 CHECK_ACCESS(_res_ptr);
16046 LDKCResult_NodeAliasDecodeErrorZ _res_conv = *(LDKCResult_NodeAliasDecodeErrorZ*)(_res_ptr);
16047 FREE(untag_ptr(_res));
16048 CResult_NodeAliasDecodeErrorZ_free(_res_conv);
16051 static inline uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg) {
16052 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16053 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(arg);
16054 return tag_ptr(ret_conv, true);
16056 int64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(uint64_t arg) {
16057 LDKCResult_NodeAliasDecodeErrorZ* arg_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(arg);
16058 int64_t ret_conv = CResult_NodeAliasDecodeErrorZ_clone_ptr(arg_conv);
16062 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone"))) TS_CResult_NodeAliasDecodeErrorZ_clone(uint64_t orig) {
16063 LDKCResult_NodeAliasDecodeErrorZ* orig_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(orig);
16064 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16065 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(orig_conv);
16066 return tag_ptr(ret_conv, true);
16069 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_ok"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint64_t o) {
16070 LDKNodeInfo o_conv;
16071 o_conv.inner = untag_ptr(o);
16072 o_conv.is_owned = ptr_is_owned(o);
16073 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16074 o_conv = NodeInfo_clone(&o_conv);
16075 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16076 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
16077 return tag_ptr(ret_conv, true);
16080 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_err"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint64_t e) {
16081 void* e_ptr = untag_ptr(e);
16082 CHECK_ACCESS(e_ptr);
16083 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16084 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16085 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16086 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
16087 return tag_ptr(ret_conv, true);
16090 jboolean __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint64_t o) {
16091 LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(o);
16092 jboolean ret_conv = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
16096 void __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_free"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint64_t _res) {
16097 if (!ptr_is_owned(_res)) return;
16098 void* _res_ptr = untag_ptr(_res);
16099 CHECK_ACCESS(_res_ptr);
16100 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(_res_ptr);
16101 FREE(untag_ptr(_res));
16102 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
16105 static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
16106 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16107 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
16108 return tag_ptr(ret_conv, true);
16110 int64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
16111 LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(arg);
16112 int64_t ret_conv = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
16116 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint64_t orig) {
16117 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(orig);
16118 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16119 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
16120 return tag_ptr(ret_conv, true);
16123 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint64_t o) {
16124 LDKNetworkGraph o_conv;
16125 o_conv.inner = untag_ptr(o);
16126 o_conv.is_owned = ptr_is_owned(o);
16127 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16128 // WARNING: we need a move here but no clone is available for LDKNetworkGraph
16130 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
16131 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
16132 return tag_ptr(ret_conv, true);
16135 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_err"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint64_t e) {
16136 void* e_ptr = untag_ptr(e);
16137 CHECK_ACCESS(e_ptr);
16138 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16139 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16140 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
16141 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
16142 return tag_ptr(ret_conv, true);
16145 jboolean __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_is_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint64_t o) {
16146 LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(o);
16147 jboolean ret_conv = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
16151 void __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_free"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint64_t _res) {
16152 if (!ptr_is_owned(_res)) return;
16153 void* _res_ptr = untag_ptr(_res);
16154 CHECK_ACCESS(_res_ptr);
16155 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(_res_ptr);
16156 FREE(untag_ptr(_res));
16157 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
16160 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_some"))) TS_COption_CVec_NetAddressZZ_some(uint64_tArray o) {
16161 LDKCVec_NetAddressZ o_constr;
16162 o_constr.datalen = o->arr_len;
16163 if (o_constr.datalen > 0)
16164 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
16166 o_constr.data = NULL;
16167 uint64_t* o_vals = o->elems;
16168 for (size_t m = 0; m < o_constr.datalen; m++) {
16169 uint64_t o_conv_12 = o_vals[m];
16170 void* o_conv_12_ptr = untag_ptr(o_conv_12);
16171 CHECK_ACCESS(o_conv_12_ptr);
16172 LDKNetAddress o_conv_12_conv = *(LDKNetAddress*)(o_conv_12_ptr);
16173 o_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o_conv_12));
16174 o_constr.data[m] = o_conv_12_conv;
16177 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16178 *ret_copy = COption_CVec_NetAddressZZ_some(o_constr);
16179 uint64_t ret_ref = tag_ptr(ret_copy, true);
16183 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_none"))) TS_COption_CVec_NetAddressZZ_none() {
16184 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16185 *ret_copy = COption_CVec_NetAddressZZ_none();
16186 uint64_t ret_ref = tag_ptr(ret_copy, true);
16190 void __attribute__((export_name("TS_COption_CVec_NetAddressZZ_free"))) TS_COption_CVec_NetAddressZZ_free(uint64_t _res) {
16191 if (!ptr_is_owned(_res)) return;
16192 void* _res_ptr = untag_ptr(_res);
16193 CHECK_ACCESS(_res_ptr);
16194 LDKCOption_CVec_NetAddressZZ _res_conv = *(LDKCOption_CVec_NetAddressZZ*)(_res_ptr);
16195 FREE(untag_ptr(_res));
16196 COption_CVec_NetAddressZZ_free(_res_conv);
16199 static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
16200 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16201 *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
16202 uint64_t ret_ref = tag_ptr(ret_copy, true);
16205 int64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone_ptr"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint64_t arg) {
16206 LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(arg);
16207 int64_t ret_conv = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
16211 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone"))) TS_COption_CVec_NetAddressZZ_clone(uint64_t orig) {
16212 LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(orig);
16213 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16214 *ret_copy = COption_CVec_NetAddressZZ_clone(orig_conv);
16215 uint64_t ret_ref = tag_ptr(ret_copy, true);
16219 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
16220 LDKDelayedPaymentOutputDescriptor o_conv;
16221 o_conv.inner = untag_ptr(o);
16222 o_conv.is_owned = ptr_is_owned(o);
16223 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16224 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
16225 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16226 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
16227 return tag_ptr(ret_conv, true);
16230 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
16231 void* e_ptr = untag_ptr(e);
16232 CHECK_ACCESS(e_ptr);
16233 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16234 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16235 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16236 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
16237 return tag_ptr(ret_conv, true);
16240 jboolean __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
16241 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
16242 jboolean ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
16246 void __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
16247 if (!ptr_is_owned(_res)) return;
16248 void* _res_ptr = untag_ptr(_res);
16249 CHECK_ACCESS(_res_ptr);
16250 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
16251 FREE(untag_ptr(_res));
16252 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
16255 static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16256 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16257 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
16258 return tag_ptr(ret_conv, true);
16260 int64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16261 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16262 int64_t ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16266 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16267 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16268 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16269 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
16270 return tag_ptr(ret_conv, true);
16273 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
16274 LDKStaticPaymentOutputDescriptor o_conv;
16275 o_conv.inner = untag_ptr(o);
16276 o_conv.is_owned = ptr_is_owned(o);
16277 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16278 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
16279 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16280 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
16281 return tag_ptr(ret_conv, true);
16284 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
16285 void* e_ptr = untag_ptr(e);
16286 CHECK_ACCESS(e_ptr);
16287 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16288 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16289 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16290 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
16291 return tag_ptr(ret_conv, true);
16294 jboolean __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
16295 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
16296 jboolean ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
16300 void __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
16301 if (!ptr_is_owned(_res)) return;
16302 void* _res_ptr = untag_ptr(_res);
16303 CHECK_ACCESS(_res_ptr);
16304 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
16305 FREE(untag_ptr(_res));
16306 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
16309 static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16310 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16311 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
16312 return tag_ptr(ret_conv, true);
16314 int64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16315 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16316 int64_t ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16320 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16321 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16322 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16323 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
16324 return tag_ptr(ret_conv, true);
16327 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
16328 void* o_ptr = untag_ptr(o);
16329 CHECK_ACCESS(o_ptr);
16330 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(o_ptr);
16331 o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(o));
16332 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16333 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
16334 return tag_ptr(ret_conv, true);
16337 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(uint64_t e) {
16338 void* e_ptr = untag_ptr(e);
16339 CHECK_ACCESS(e_ptr);
16340 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16341 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16342 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16343 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
16344 return tag_ptr(ret_conv, true);
16347 jboolean __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
16348 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(o);
16349 jboolean ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
16353 void __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
16354 if (!ptr_is_owned(_res)) return;
16355 void* _res_ptr = untag_ptr(_res);
16356 CHECK_ACCESS(_res_ptr);
16357 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(_res_ptr);
16358 FREE(untag_ptr(_res));
16359 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
16362 static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16363 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16364 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
16365 return tag_ptr(ret_conv, true);
16367 int64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16368 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16369 int64_t ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16373 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16374 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16375 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16376 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
16377 return tag_ptr(ret_conv, true);
16380 void __attribute__((export_name("TS_CVec_PaymentPreimageZ_free"))) TS_CVec_PaymentPreimageZ_free(ptrArray _res) {
16381 LDKCVec_PaymentPreimageZ _res_constr;
16382 _res_constr.datalen = _res->arr_len;
16383 if (_res_constr.datalen > 0)
16384 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
16386 _res_constr.data = NULL;
16387 int8_tArray* _res_vals = (void*) _res->elems;
16388 for (size_t m = 0; m < _res_constr.datalen; m++) {
16389 int8_tArray _res_conv_12 = _res_vals[m];
16390 LDKThirtyTwoBytes _res_conv_12_ref;
16391 CHECK(_res_conv_12->arr_len == 32);
16392 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
16393 _res_constr.data[m] = _res_conv_12_ref;
16396 CVec_PaymentPreimageZ_free(_res_constr);
16399 static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
16400 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
16401 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
16402 return tag_ptr(ret_conv, true);
16404 int64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint64_t arg) {
16405 LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(arg);
16406 int64_t ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
16410 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint64_t orig) {
16411 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(orig);
16412 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
16413 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
16414 return tag_ptr(ret_conv, true);
16417 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_new"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
16418 LDKSignature a_ref;
16419 CHECK(a->arr_len == 64);
16420 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
16421 LDKCVec_SignatureZ b_constr;
16422 b_constr.datalen = b->arr_len;
16423 if (b_constr.datalen > 0)
16424 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
16426 b_constr.data = NULL;
16427 int8_tArray* b_vals = (void*) b->elems;
16428 for (size_t m = 0; m < b_constr.datalen; m++) {
16429 int8_tArray b_conv_12 = b_vals[m];
16430 LDKSignature b_conv_12_ref;
16431 CHECK(b_conv_12->arr_len == 64);
16432 memcpy(b_conv_12_ref.compact_form, b_conv_12->elems, 64); FREE(b_conv_12);
16433 b_constr.data[m] = b_conv_12_ref;
16436 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
16437 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
16438 return tag_ptr(ret_conv, true);
16441 void __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_free"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint64_t _res) {
16442 if (!ptr_is_owned(_res)) return;
16443 void* _res_ptr = untag_ptr(_res);
16444 CHECK_ACCESS(_res_ptr);
16445 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(_res_ptr);
16446 FREE(untag_ptr(_res));
16447 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
16450 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint64_t o) {
16451 void* o_ptr = untag_ptr(o);
16452 CHECK_ACCESS(o_ptr);
16453 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(o_ptr);
16454 o_conv = C2Tuple_SignatureCVec_SignatureZZ_clone((LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(o));
16455 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16456 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
16457 return tag_ptr(ret_conv, true);
16460 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() {
16461 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16462 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
16463 return tag_ptr(ret_conv, true);
16466 jboolean __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint64_t o) {
16467 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(o);
16468 jboolean ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
16472 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint64_t _res) {
16473 if (!ptr_is_owned(_res)) return;
16474 void* _res_ptr = untag_ptr(_res);
16475 CHECK_ACCESS(_res_ptr);
16476 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(_res_ptr);
16477 FREE(untag_ptr(_res));
16478 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
16481 static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
16482 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16483 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
16484 return tag_ptr(ret_conv, true);
16486 int64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint64_t arg) {
16487 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(arg);
16488 int64_t ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
16492 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint64_t orig) {
16493 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(orig);
16494 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16495 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
16496 return tag_ptr(ret_conv, true);
16499 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_ok"))) TS_CResult_SignatureNoneZ_ok(int8_tArray o) {
16500 LDKSignature o_ref;
16501 CHECK(o->arr_len == 64);
16502 memcpy(o_ref.compact_form, o->elems, 64); FREE(o);
16503 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16504 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
16505 return tag_ptr(ret_conv, true);
16508 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_err"))) TS_CResult_SignatureNoneZ_err() {
16509 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16510 *ret_conv = CResult_SignatureNoneZ_err();
16511 return tag_ptr(ret_conv, true);
16514 jboolean __attribute__((export_name("TS_CResult_SignatureNoneZ_is_ok"))) TS_CResult_SignatureNoneZ_is_ok(uint64_t o) {
16515 LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(o);
16516 jboolean ret_conv = CResult_SignatureNoneZ_is_ok(o_conv);
16520 void __attribute__((export_name("TS_CResult_SignatureNoneZ_free"))) TS_CResult_SignatureNoneZ_free(uint64_t _res) {
16521 if (!ptr_is_owned(_res)) return;
16522 void* _res_ptr = untag_ptr(_res);
16523 CHECK_ACCESS(_res_ptr);
16524 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(_res_ptr);
16525 FREE(untag_ptr(_res));
16526 CResult_SignatureNoneZ_free(_res_conv);
16529 static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
16530 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16531 *ret_conv = CResult_SignatureNoneZ_clone(arg);
16532 return tag_ptr(ret_conv, true);
16534 int64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone_ptr"))) TS_CResult_SignatureNoneZ_clone_ptr(uint64_t arg) {
16535 LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(arg);
16536 int64_t ret_conv = CResult_SignatureNoneZ_clone_ptr(arg_conv);
16540 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone"))) TS_CResult_SignatureNoneZ_clone(uint64_t orig) {
16541 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(orig);
16542 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16543 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
16544 return tag_ptr(ret_conv, true);
16547 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_ok"))) TS_CResult_PublicKeyNoneZ_ok(int8_tArray o) {
16548 LDKPublicKey o_ref;
16549 CHECK(o->arr_len == 33);
16550 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
16551 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16552 *ret_conv = CResult_PublicKeyNoneZ_ok(o_ref);
16553 return tag_ptr(ret_conv, true);
16556 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_err"))) TS_CResult_PublicKeyNoneZ_err() {
16557 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16558 *ret_conv = CResult_PublicKeyNoneZ_err();
16559 return tag_ptr(ret_conv, true);
16562 jboolean __attribute__((export_name("TS_CResult_PublicKeyNoneZ_is_ok"))) TS_CResult_PublicKeyNoneZ_is_ok(uint64_t o) {
16563 LDKCResult_PublicKeyNoneZ* o_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(o);
16564 jboolean ret_conv = CResult_PublicKeyNoneZ_is_ok(o_conv);
16568 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_free"))) TS_CResult_PublicKeyNoneZ_free(uint64_t _res) {
16569 if (!ptr_is_owned(_res)) return;
16570 void* _res_ptr = untag_ptr(_res);
16571 CHECK_ACCESS(_res_ptr);
16572 LDKCResult_PublicKeyNoneZ _res_conv = *(LDKCResult_PublicKeyNoneZ*)(_res_ptr);
16573 FREE(untag_ptr(_res));
16574 CResult_PublicKeyNoneZ_free(_res_conv);
16577 static inline uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg) {
16578 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16579 *ret_conv = CResult_PublicKeyNoneZ_clone(arg);
16580 return tag_ptr(ret_conv, true);
16582 int64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone_ptr"))) TS_CResult_PublicKeyNoneZ_clone_ptr(uint64_t arg) {
16583 LDKCResult_PublicKeyNoneZ* arg_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(arg);
16584 int64_t ret_conv = CResult_PublicKeyNoneZ_clone_ptr(arg_conv);
16588 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone"))) TS_CResult_PublicKeyNoneZ_clone(uint64_t orig) {
16589 LDKCResult_PublicKeyNoneZ* orig_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(orig);
16590 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16591 *ret_conv = CResult_PublicKeyNoneZ_clone(orig_conv);
16592 return tag_ptr(ret_conv, true);
16595 uint64_t __attribute__((export_name("TS_COption_ScalarZ_some"))) TS_COption_ScalarZ_some(uint64_t o) {
16596 void* o_ptr = untag_ptr(o);
16597 CHECK_ACCESS(o_ptr);
16598 LDKBigEndianScalar o_conv = *(LDKBigEndianScalar*)(o_ptr);
16599 // WARNING: we may need a move here but no clone is available for LDKBigEndianScalar
16600 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16601 *ret_copy = COption_ScalarZ_some(o_conv);
16602 uint64_t ret_ref = tag_ptr(ret_copy, true);
16606 uint64_t __attribute__((export_name("TS_COption_ScalarZ_none"))) TS_COption_ScalarZ_none() {
16607 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16608 *ret_copy = COption_ScalarZ_none();
16609 uint64_t ret_ref = tag_ptr(ret_copy, true);
16613 void __attribute__((export_name("TS_COption_ScalarZ_free"))) TS_COption_ScalarZ_free(uint64_t _res) {
16614 if (!ptr_is_owned(_res)) return;
16615 void* _res_ptr = untag_ptr(_res);
16616 CHECK_ACCESS(_res_ptr);
16617 LDKCOption_ScalarZ _res_conv = *(LDKCOption_ScalarZ*)(_res_ptr);
16618 FREE(untag_ptr(_res));
16619 COption_ScalarZ_free(_res_conv);
16622 static inline uint64_t COption_ScalarZ_clone_ptr(LDKCOption_ScalarZ *NONNULL_PTR arg) {
16623 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16624 *ret_copy = COption_ScalarZ_clone(arg);
16625 uint64_t ret_ref = tag_ptr(ret_copy, true);
16628 int64_t __attribute__((export_name("TS_COption_ScalarZ_clone_ptr"))) TS_COption_ScalarZ_clone_ptr(uint64_t arg) {
16629 LDKCOption_ScalarZ* arg_conv = (LDKCOption_ScalarZ*)untag_ptr(arg);
16630 int64_t ret_conv = COption_ScalarZ_clone_ptr(arg_conv);
16634 uint64_t __attribute__((export_name("TS_COption_ScalarZ_clone"))) TS_COption_ScalarZ_clone(uint64_t orig) {
16635 LDKCOption_ScalarZ* orig_conv = (LDKCOption_ScalarZ*)untag_ptr(orig);
16636 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16637 *ret_copy = COption_ScalarZ_clone(orig_conv);
16638 uint64_t ret_ref = tag_ptr(ret_copy, true);
16642 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_ok"))) TS_CResult_SharedSecretNoneZ_ok(int8_tArray o) {
16643 LDKThirtyTwoBytes o_ref;
16644 CHECK(o->arr_len == 32);
16645 memcpy(o_ref.data, o->elems, 32); FREE(o);
16646 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16647 *ret_conv = CResult_SharedSecretNoneZ_ok(o_ref);
16648 return tag_ptr(ret_conv, true);
16651 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_err"))) TS_CResult_SharedSecretNoneZ_err() {
16652 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16653 *ret_conv = CResult_SharedSecretNoneZ_err();
16654 return tag_ptr(ret_conv, true);
16657 jboolean __attribute__((export_name("TS_CResult_SharedSecretNoneZ_is_ok"))) TS_CResult_SharedSecretNoneZ_is_ok(uint64_t o) {
16658 LDKCResult_SharedSecretNoneZ* o_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(o);
16659 jboolean ret_conv = CResult_SharedSecretNoneZ_is_ok(o_conv);
16663 void __attribute__((export_name("TS_CResult_SharedSecretNoneZ_free"))) TS_CResult_SharedSecretNoneZ_free(uint64_t _res) {
16664 if (!ptr_is_owned(_res)) return;
16665 void* _res_ptr = untag_ptr(_res);
16666 CHECK_ACCESS(_res_ptr);
16667 LDKCResult_SharedSecretNoneZ _res_conv = *(LDKCResult_SharedSecretNoneZ*)(_res_ptr);
16668 FREE(untag_ptr(_res));
16669 CResult_SharedSecretNoneZ_free(_res_conv);
16672 static inline uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg) {
16673 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16674 *ret_conv = CResult_SharedSecretNoneZ_clone(arg);
16675 return tag_ptr(ret_conv, true);
16677 int64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_clone_ptr"))) TS_CResult_SharedSecretNoneZ_clone_ptr(uint64_t arg) {
16678 LDKCResult_SharedSecretNoneZ* arg_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(arg);
16679 int64_t ret_conv = CResult_SharedSecretNoneZ_clone_ptr(arg_conv);
16683 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_clone"))) TS_CResult_SharedSecretNoneZ_clone(uint64_t orig) {
16684 LDKCResult_SharedSecretNoneZ* orig_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(orig);
16685 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16686 *ret_conv = CResult_SharedSecretNoneZ_clone(orig_conv);
16687 return tag_ptr(ret_conv, true);
16690 void __attribute__((export_name("TS_CVec_U5Z_free"))) TS_CVec_U5Z_free(ptrArray _res) {
16691 LDKCVec_U5Z _res_constr;
16692 _res_constr.datalen = _res->arr_len;
16693 if (_res_constr.datalen > 0)
16694 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
16696 _res_constr.data = NULL;
16697 int8_t* _res_vals = (void*) _res->elems;
16698 for (size_t h = 0; h < _res_constr.datalen; h++) {
16699 int8_t _res_conv_7 = _res_vals[h];
16701 _res_constr.data[h] = (LDKU5){ ._0 = _res_conv_7 };
16704 CVec_U5Z_free(_res_constr);
16707 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_ok"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray o) {
16708 LDKRecoverableSignature o_ref;
16709 CHECK(o->arr_len == 68);
16710 memcpy(o_ref.serialized_form, o->elems, 68); FREE(o);
16711 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16712 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(o_ref);
16713 return tag_ptr(ret_conv, true);
16716 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_err"))) TS_CResult_RecoverableSignatureNoneZ_err() {
16717 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16718 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
16719 return tag_ptr(ret_conv, true);
16722 jboolean __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_is_ok"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint64_t o) {
16723 LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(o);
16724 jboolean ret_conv = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
16728 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_free"))) TS_CResult_RecoverableSignatureNoneZ_free(uint64_t _res) {
16729 if (!ptr_is_owned(_res)) return;
16730 void* _res_ptr = untag_ptr(_res);
16731 CHECK_ACCESS(_res_ptr);
16732 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(_res_ptr);
16733 FREE(untag_ptr(_res));
16734 CResult_RecoverableSignatureNoneZ_free(_res_conv);
16737 static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
16738 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16739 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
16740 return tag_ptr(ret_conv, true);
16742 int64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone_ptr"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint64_t arg) {
16743 LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(arg);
16744 int64_t ret_conv = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
16748 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint64_t orig) {
16749 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(orig);
16750 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16751 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
16752 return tag_ptr(ret_conv, true);
16755 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(uint64_t o) {
16756 void* o_ptr = untag_ptr(o);
16757 CHECK_ACCESS(o_ptr);
16758 LDKWriteableEcdsaChannelSigner o_conv = *(LDKWriteableEcdsaChannelSigner*)(o_ptr);
16759 if (o_conv.free == LDKWriteableEcdsaChannelSigner_JCalls_free) {
16760 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16761 LDKWriteableEcdsaChannelSigner_JCalls_cloned(&o_conv);
16763 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16764 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o_conv);
16765 return tag_ptr(ret_conv, true);
16768 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(uint64_t e) {
16769 void* e_ptr = untag_ptr(e);
16770 CHECK_ACCESS(e_ptr);
16771 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16772 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16773 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16774 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e_conv);
16775 return tag_ptr(ret_conv, true);
16778 jboolean __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(uint64_t o) {
16779 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* o_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(o);
16780 jboolean ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o_conv);
16784 void __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(uint64_t _res) {
16785 if (!ptr_is_owned(_res)) return;
16786 void* _res_ptr = untag_ptr(_res);
16787 CHECK_ACCESS(_res_ptr);
16788 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res_conv = *(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)(_res_ptr);
16789 FREE(untag_ptr(_res));
16790 CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res_conv);
16793 static inline uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg) {
16794 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16795 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(arg);
16796 return tag_ptr(ret_conv, true);
16798 int64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16799 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* arg_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(arg);
16800 int64_t ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg_conv);
16804 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(uint64_t orig) {
16805 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* orig_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(orig);
16806 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16807 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig_conv);
16808 return tag_ptr(ret_conv, true);
16811 void __attribute__((export_name("TS_CVec_CVec_u8ZZ_free"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
16812 LDKCVec_CVec_u8ZZ _res_constr;
16813 _res_constr.datalen = _res->arr_len;
16814 if (_res_constr.datalen > 0)
16815 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16817 _res_constr.data = NULL;
16818 int8_tArray* _res_vals = (void*) _res->elems;
16819 for (size_t m = 0; m < _res_constr.datalen; m++) {
16820 int8_tArray _res_conv_12 = _res_vals[m];
16821 LDKCVec_u8Z _res_conv_12_ref;
16822 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
16823 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16824 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
16825 _res_constr.data[m] = _res_conv_12_ref;
16828 CVec_CVec_u8ZZ_free(_res_constr);
16831 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
16832 LDKCVec_CVec_u8ZZ o_constr;
16833 o_constr.datalen = o->arr_len;
16834 if (o_constr.datalen > 0)
16835 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16837 o_constr.data = NULL;
16838 int8_tArray* o_vals = (void*) o->elems;
16839 for (size_t m = 0; m < o_constr.datalen; m++) {
16840 int8_tArray o_conv_12 = o_vals[m];
16841 LDKCVec_u8Z o_conv_12_ref;
16842 o_conv_12_ref.datalen = o_conv_12->arr_len;
16843 o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16844 memcpy(o_conv_12_ref.data, o_conv_12->elems, o_conv_12_ref.datalen); FREE(o_conv_12);
16845 o_constr.data[m] = o_conv_12_ref;
16848 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16849 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
16850 return tag_ptr(ret_conv, true);
16853 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
16854 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16855 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
16856 return tag_ptr(ret_conv, true);
16859 jboolean __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint64_t o) {
16860 LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(o);
16861 jboolean ret_conv = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
16865 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_free"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint64_t _res) {
16866 if (!ptr_is_owned(_res)) return;
16867 void* _res_ptr = untag_ptr(_res);
16868 CHECK_ACCESS(_res_ptr);
16869 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(_res_ptr);
16870 FREE(untag_ptr(_res));
16871 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
16874 static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
16875 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16876 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
16877 return tag_ptr(ret_conv, true);
16879 int64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint64_t arg) {
16880 LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(arg);
16881 int64_t ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
16885 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint64_t orig) {
16886 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(orig);
16887 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16888 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
16889 return tag_ptr(ret_conv, true);
16892 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint64_t o) {
16893 LDKInMemorySigner o_conv;
16894 o_conv.inner = untag_ptr(o);
16895 o_conv.is_owned = ptr_is_owned(o);
16896 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16897 o_conv = InMemorySigner_clone(&o_conv);
16898 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16899 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
16900 return tag_ptr(ret_conv, true);
16903 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_err"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint64_t e) {
16904 void* e_ptr = untag_ptr(e);
16905 CHECK_ACCESS(e_ptr);
16906 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16907 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16908 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16909 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
16910 return tag_ptr(ret_conv, true);
16913 jboolean __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_is_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint64_t o) {
16914 LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(o);
16915 jboolean ret_conv = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
16919 void __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_free"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint64_t _res) {
16920 if (!ptr_is_owned(_res)) return;
16921 void* _res_ptr = untag_ptr(_res);
16922 CHECK_ACCESS(_res_ptr);
16923 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(_res_ptr);
16924 FREE(untag_ptr(_res));
16925 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
16928 static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
16929 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16930 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
16931 return tag_ptr(ret_conv, true);
16933 int64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16934 LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(arg);
16935 int64_t ret_conv = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
16939 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint64_t orig) {
16940 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(orig);
16941 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16942 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
16943 return tag_ptr(ret_conv, true);
16946 void __attribute__((export_name("TS_CVec_TxOutZ_free"))) TS_CVec_TxOutZ_free(uint64_tArray _res) {
16947 LDKCVec_TxOutZ _res_constr;
16948 _res_constr.datalen = _res->arr_len;
16949 if (_res_constr.datalen > 0)
16950 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
16952 _res_constr.data = NULL;
16953 uint64_t* _res_vals = _res->elems;
16954 for (size_t h = 0; h < _res_constr.datalen; h++) {
16955 uint64_t _res_conv_7 = _res_vals[h];
16956 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
16957 CHECK_ACCESS(_res_conv_7_ptr);
16958 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(_res_conv_7_ptr);
16959 FREE(untag_ptr(_res_conv_7));
16960 _res_constr.data[h] = _res_conv_7_conv;
16963 CVec_TxOutZ_free(_res_constr);
16966 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_ok"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
16967 LDKTransaction o_ref;
16968 o_ref.datalen = o->arr_len;
16969 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
16970 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
16971 o_ref.data_is_owned = true;
16972 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16973 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
16974 return tag_ptr(ret_conv, true);
16977 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_err"))) TS_CResult_TransactionNoneZ_err() {
16978 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16979 *ret_conv = CResult_TransactionNoneZ_err();
16980 return tag_ptr(ret_conv, true);
16983 jboolean __attribute__((export_name("TS_CResult_TransactionNoneZ_is_ok"))) TS_CResult_TransactionNoneZ_is_ok(uint64_t o) {
16984 LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(o);
16985 jboolean ret_conv = CResult_TransactionNoneZ_is_ok(o_conv);
16989 void __attribute__((export_name("TS_CResult_TransactionNoneZ_free"))) TS_CResult_TransactionNoneZ_free(uint64_t _res) {
16990 if (!ptr_is_owned(_res)) return;
16991 void* _res_ptr = untag_ptr(_res);
16992 CHECK_ACCESS(_res_ptr);
16993 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(_res_ptr);
16994 FREE(untag_ptr(_res));
16995 CResult_TransactionNoneZ_free(_res_conv);
16998 static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
16999 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
17000 *ret_conv = CResult_TransactionNoneZ_clone(arg);
17001 return tag_ptr(ret_conv, true);
17003 int64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone_ptr"))) TS_CResult_TransactionNoneZ_clone_ptr(uint64_t arg) {
17004 LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(arg);
17005 int64_t ret_conv = CResult_TransactionNoneZ_clone_ptr(arg_conv);
17009 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone"))) TS_CResult_TransactionNoneZ_clone(uint64_t orig) {
17010 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(orig);
17011 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
17012 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
17013 return tag_ptr(ret_conv, true);
17016 uint64_t __attribute__((export_name("TS_COption_u16Z_some"))) TS_COption_u16Z_some(int16_t o) {
17017 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17018 *ret_copy = COption_u16Z_some(o);
17019 uint64_t ret_ref = tag_ptr(ret_copy, true);
17023 uint64_t __attribute__((export_name("TS_COption_u16Z_none"))) TS_COption_u16Z_none() {
17024 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17025 *ret_copy = COption_u16Z_none();
17026 uint64_t ret_ref = tag_ptr(ret_copy, true);
17030 void __attribute__((export_name("TS_COption_u16Z_free"))) TS_COption_u16Z_free(uint64_t _res) {
17031 if (!ptr_is_owned(_res)) return;
17032 void* _res_ptr = untag_ptr(_res);
17033 CHECK_ACCESS(_res_ptr);
17034 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(_res_ptr);
17035 FREE(untag_ptr(_res));
17036 COption_u16Z_free(_res_conv);
17039 static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
17040 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17041 *ret_copy = COption_u16Z_clone(arg);
17042 uint64_t ret_ref = tag_ptr(ret_copy, true);
17045 int64_t __attribute__((export_name("TS_COption_u16Z_clone_ptr"))) TS_COption_u16Z_clone_ptr(uint64_t arg) {
17046 LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)untag_ptr(arg);
17047 int64_t ret_conv = COption_u16Z_clone_ptr(arg_conv);
17051 uint64_t __attribute__((export_name("TS_COption_u16Z_clone"))) TS_COption_u16Z_clone(uint64_t orig) {
17052 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)untag_ptr(orig);
17053 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17054 *ret_copy = COption_u16Z_clone(orig_conv);
17055 uint64_t ret_ref = tag_ptr(ret_copy, true);
17059 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_ok"))) TS_CResult__u832APIErrorZ_ok(int8_tArray o) {
17060 LDKThirtyTwoBytes o_ref;
17061 CHECK(o->arr_len == 32);
17062 memcpy(o_ref.data, o->elems, 32); FREE(o);
17063 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17064 *ret_conv = CResult__u832APIErrorZ_ok(o_ref);
17065 return tag_ptr(ret_conv, true);
17068 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_err"))) TS_CResult__u832APIErrorZ_err(uint64_t e) {
17069 void* e_ptr = untag_ptr(e);
17070 CHECK_ACCESS(e_ptr);
17071 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17072 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17073 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17074 *ret_conv = CResult__u832APIErrorZ_err(e_conv);
17075 return tag_ptr(ret_conv, true);
17078 jboolean __attribute__((export_name("TS_CResult__u832APIErrorZ_is_ok"))) TS_CResult__u832APIErrorZ_is_ok(uint64_t o) {
17079 LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(o);
17080 jboolean ret_conv = CResult__u832APIErrorZ_is_ok(o_conv);
17084 void __attribute__((export_name("TS_CResult__u832APIErrorZ_free"))) TS_CResult__u832APIErrorZ_free(uint64_t _res) {
17085 if (!ptr_is_owned(_res)) return;
17086 void* _res_ptr = untag_ptr(_res);
17087 CHECK_ACCESS(_res_ptr);
17088 LDKCResult__u832APIErrorZ _res_conv = *(LDKCResult__u832APIErrorZ*)(_res_ptr);
17089 FREE(untag_ptr(_res));
17090 CResult__u832APIErrorZ_free(_res_conv);
17093 static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
17094 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17095 *ret_conv = CResult__u832APIErrorZ_clone(arg);
17096 return tag_ptr(ret_conv, true);
17098 int64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone_ptr"))) TS_CResult__u832APIErrorZ_clone_ptr(uint64_t arg) {
17099 LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(arg);
17100 int64_t ret_conv = CResult__u832APIErrorZ_clone_ptr(arg_conv);
17104 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone"))) TS_CResult__u832APIErrorZ_clone(uint64_t orig) {
17105 LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(orig);
17106 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17107 *ret_conv = CResult__u832APIErrorZ_clone(orig_conv);
17108 return tag_ptr(ret_conv, true);
17111 void __attribute__((export_name("TS_CVec_RecentPaymentDetailsZ_free"))) TS_CVec_RecentPaymentDetailsZ_free(uint64_tArray _res) {
17112 LDKCVec_RecentPaymentDetailsZ _res_constr;
17113 _res_constr.datalen = _res->arr_len;
17114 if (_res_constr.datalen > 0)
17115 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRecentPaymentDetails), "LDKCVec_RecentPaymentDetailsZ Elements");
17117 _res_constr.data = NULL;
17118 uint64_t* _res_vals = _res->elems;
17119 for (size_t w = 0; w < _res_constr.datalen; w++) {
17120 uint64_t _res_conv_22 = _res_vals[w];
17121 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
17122 CHECK_ACCESS(_res_conv_22_ptr);
17123 LDKRecentPaymentDetails _res_conv_22_conv = *(LDKRecentPaymentDetails*)(_res_conv_22_ptr);
17124 FREE(untag_ptr(_res_conv_22));
17125 _res_constr.data[w] = _res_conv_22_conv;
17128 CVec_RecentPaymentDetailsZ_free(_res_constr);
17131 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_ok"))) TS_CResult_NonePaymentSendFailureZ_ok() {
17132 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17133 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
17134 return tag_ptr(ret_conv, true);
17137 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_err"))) TS_CResult_NonePaymentSendFailureZ_err(uint64_t e) {
17138 void* e_ptr = untag_ptr(e);
17139 CHECK_ACCESS(e_ptr);
17140 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
17141 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
17142 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17143 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
17144 return tag_ptr(ret_conv, true);
17147 jboolean __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_is_ok"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint64_t o) {
17148 LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(o);
17149 jboolean ret_conv = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
17153 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_free"))) TS_CResult_NonePaymentSendFailureZ_free(uint64_t _res) {
17154 if (!ptr_is_owned(_res)) return;
17155 void* _res_ptr = untag_ptr(_res);
17156 CHECK_ACCESS(_res_ptr);
17157 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(_res_ptr);
17158 FREE(untag_ptr(_res));
17159 CResult_NonePaymentSendFailureZ_free(_res_conv);
17162 static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
17163 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17164 *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
17165 return tag_ptr(ret_conv, true);
17167 int64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone_ptr"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint64_t arg) {
17168 LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(arg);
17169 int64_t ret_conv = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
17173 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone"))) TS_CResult_NonePaymentSendFailureZ_clone(uint64_t orig) {
17174 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(orig);
17175 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17176 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
17177 return tag_ptr(ret_conv, true);
17180 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_ok"))) TS_CResult_NoneRetryableSendFailureZ_ok() {
17181 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17182 *ret_conv = CResult_NoneRetryableSendFailureZ_ok();
17183 return tag_ptr(ret_conv, true);
17186 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_err"))) TS_CResult_NoneRetryableSendFailureZ_err(uint32_t e) {
17187 LDKRetryableSendFailure e_conv = LDKRetryableSendFailure_from_js(e);
17188 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17189 *ret_conv = CResult_NoneRetryableSendFailureZ_err(e_conv);
17190 return tag_ptr(ret_conv, true);
17193 jboolean __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_is_ok"))) TS_CResult_NoneRetryableSendFailureZ_is_ok(uint64_t o) {
17194 LDKCResult_NoneRetryableSendFailureZ* o_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(o);
17195 jboolean ret_conv = CResult_NoneRetryableSendFailureZ_is_ok(o_conv);
17199 void __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_free"))) TS_CResult_NoneRetryableSendFailureZ_free(uint64_t _res) {
17200 if (!ptr_is_owned(_res)) return;
17201 void* _res_ptr = untag_ptr(_res);
17202 CHECK_ACCESS(_res_ptr);
17203 LDKCResult_NoneRetryableSendFailureZ _res_conv = *(LDKCResult_NoneRetryableSendFailureZ*)(_res_ptr);
17204 FREE(untag_ptr(_res));
17205 CResult_NoneRetryableSendFailureZ_free(_res_conv);
17208 static inline uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg) {
17209 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17210 *ret_conv = CResult_NoneRetryableSendFailureZ_clone(arg);
17211 return tag_ptr(ret_conv, true);
17213 int64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_clone_ptr"))) TS_CResult_NoneRetryableSendFailureZ_clone_ptr(uint64_t arg) {
17214 LDKCResult_NoneRetryableSendFailureZ* arg_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(arg);
17215 int64_t ret_conv = CResult_NoneRetryableSendFailureZ_clone_ptr(arg_conv);
17219 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_clone"))) TS_CResult_NoneRetryableSendFailureZ_clone(uint64_t orig) {
17220 LDKCResult_NoneRetryableSendFailureZ* orig_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(orig);
17221 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17222 *ret_conv = CResult_NoneRetryableSendFailureZ_clone(orig_conv);
17223 return tag_ptr(ret_conv, true);
17226 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_ok(int8_tArray o) {
17227 LDKThirtyTwoBytes o_ref;
17228 CHECK(o->arr_len == 32);
17229 memcpy(o_ref.data, o->elems, 32); FREE(o);
17230 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17231 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_ok(o_ref);
17232 return tag_ptr(ret_conv, true);
17235 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_err"))) TS_CResult_PaymentHashPaymentSendFailureZ_err(uint64_t e) {
17236 void* e_ptr = untag_ptr(e);
17237 CHECK_ACCESS(e_ptr);
17238 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
17239 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
17240 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17241 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_err(e_conv);
17242 return tag_ptr(ret_conv, true);
17245 jboolean __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_is_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_is_ok(uint64_t o) {
17246 LDKCResult_PaymentHashPaymentSendFailureZ* o_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(o);
17247 jboolean ret_conv = CResult_PaymentHashPaymentSendFailureZ_is_ok(o_conv);
17251 void __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_free"))) TS_CResult_PaymentHashPaymentSendFailureZ_free(uint64_t _res) {
17252 if (!ptr_is_owned(_res)) return;
17253 void* _res_ptr = untag_ptr(_res);
17254 CHECK_ACCESS(_res_ptr);
17255 LDKCResult_PaymentHashPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentHashPaymentSendFailureZ*)(_res_ptr);
17256 FREE(untag_ptr(_res));
17257 CResult_PaymentHashPaymentSendFailureZ_free(_res_conv);
17260 static inline uint64_t CResult_PaymentHashPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR arg) {
17261 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17262 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(arg);
17263 return tag_ptr(ret_conv, true);
17265 int64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr(uint64_t arg) {
17266 LDKCResult_PaymentHashPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(arg);
17267 int64_t ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg_conv);
17271 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_clone"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone(uint64_t orig) {
17272 LDKCResult_PaymentHashPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(orig);
17273 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17274 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(orig_conv);
17275 return tag_ptr(ret_conv, true);
17278 uint64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_ok"))) TS_CResult_PaymentHashRetryableSendFailureZ_ok(int8_tArray o) {
17279 LDKThirtyTwoBytes o_ref;
17280 CHECK(o->arr_len == 32);
17281 memcpy(o_ref.data, o->elems, 32); FREE(o);
17282 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17283 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_ok(o_ref);
17284 return tag_ptr(ret_conv, true);
17287 uint64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_err"))) TS_CResult_PaymentHashRetryableSendFailureZ_err(uint32_t e) {
17288 LDKRetryableSendFailure e_conv = LDKRetryableSendFailure_from_js(e);
17289 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17290 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_err(e_conv);
17291 return tag_ptr(ret_conv, true);
17294 jboolean __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_is_ok"))) TS_CResult_PaymentHashRetryableSendFailureZ_is_ok(uint64_t o) {
17295 LDKCResult_PaymentHashRetryableSendFailureZ* o_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(o);
17296 jboolean ret_conv = CResult_PaymentHashRetryableSendFailureZ_is_ok(o_conv);
17300 void __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_free"))) TS_CResult_PaymentHashRetryableSendFailureZ_free(uint64_t _res) {
17301 if (!ptr_is_owned(_res)) return;
17302 void* _res_ptr = untag_ptr(_res);
17303 CHECK_ACCESS(_res_ptr);
17304 LDKCResult_PaymentHashRetryableSendFailureZ _res_conv = *(LDKCResult_PaymentHashRetryableSendFailureZ*)(_res_ptr);
17305 FREE(untag_ptr(_res));
17306 CResult_PaymentHashRetryableSendFailureZ_free(_res_conv);
17309 static inline uint64_t CResult_PaymentHashRetryableSendFailureZ_clone_ptr(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR arg) {
17310 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17311 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_clone(arg);
17312 return tag_ptr(ret_conv, true);
17314 int64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_clone_ptr"))) TS_CResult_PaymentHashRetryableSendFailureZ_clone_ptr(uint64_t arg) {
17315 LDKCResult_PaymentHashRetryableSendFailureZ* arg_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(arg);
17316 int64_t ret_conv = CResult_PaymentHashRetryableSendFailureZ_clone_ptr(arg_conv);
17320 uint64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_clone"))) TS_CResult_PaymentHashRetryableSendFailureZ_clone(uint64_t orig) {
17321 LDKCResult_PaymentHashRetryableSendFailureZ* orig_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(orig);
17322 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17323 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_clone(orig_conv);
17324 return tag_ptr(ret_conv, true);
17327 static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
17328 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
17329 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
17330 return tag_ptr(ret_conv, true);
17332 int64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint64_t arg) {
17333 LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(arg);
17334 int64_t ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
17338 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint64_t orig) {
17339 LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(orig);
17340 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
17341 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(orig_conv);
17342 return tag_ptr(ret_conv, true);
17345 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_new"))) TS_C2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, int8_tArray b) {
17346 LDKThirtyTwoBytes a_ref;
17347 CHECK(a->arr_len == 32);
17348 memcpy(a_ref.data, a->elems, 32); FREE(a);
17349 LDKThirtyTwoBytes b_ref;
17350 CHECK(b->arr_len == 32);
17351 memcpy(b_ref.data, b->elems, 32); FREE(b);
17352 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
17353 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_new(a_ref, b_ref);
17354 return tag_ptr(ret_conv, true);
17357 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_free"))) TS_C2Tuple_PaymentHashPaymentIdZ_free(uint64_t _res) {
17358 if (!ptr_is_owned(_res)) return;
17359 void* _res_ptr = untag_ptr(_res);
17360 CHECK_ACCESS(_res_ptr);
17361 LDKC2Tuple_PaymentHashPaymentIdZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(_res_ptr);
17362 FREE(untag_ptr(_res));
17363 C2Tuple_PaymentHashPaymentIdZ_free(_res_conv);
17366 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(uint64_t o) {
17367 void* o_ptr = untag_ptr(o);
17368 CHECK_ACCESS(o_ptr);
17369 LDKC2Tuple_PaymentHashPaymentIdZ o_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(o_ptr);
17370 o_conv = C2Tuple_PaymentHashPaymentIdZ_clone((LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(o));
17371 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17372 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o_conv);
17373 return tag_ptr(ret_conv, true);
17376 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(uint64_t e) {
17377 void* e_ptr = untag_ptr(e);
17378 CHECK_ACCESS(e_ptr);
17379 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
17380 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
17381 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17382 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e_conv);
17383 return tag_ptr(ret_conv, true);
17386 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint64_t o) {
17387 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(o);
17388 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
17392 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint64_t _res) {
17393 if (!ptr_is_owned(_res)) return;
17394 void* _res_ptr = untag_ptr(_res);
17395 CHECK_ACCESS(_res_ptr);
17396 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(_res_ptr);
17397 FREE(untag_ptr(_res));
17398 CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
17401 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
17402 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17403 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
17404 return tag_ptr(ret_conv, true);
17406 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint64_t arg) {
17407 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(arg);
17408 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
17412 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint64_t orig) {
17413 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(orig);
17414 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17415 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig_conv);
17416 return tag_ptr(ret_conv, true);
17419 void __attribute__((export_name("TS_CVec_ThirtyTwoBytesZ_free"))) TS_CVec_ThirtyTwoBytesZ_free(ptrArray _res) {
17420 LDKCVec_ThirtyTwoBytesZ _res_constr;
17421 _res_constr.datalen = _res->arr_len;
17422 if (_res_constr.datalen > 0)
17423 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
17425 _res_constr.data = NULL;
17426 int8_tArray* _res_vals = (void*) _res->elems;
17427 for (size_t m = 0; m < _res_constr.datalen; m++) {
17428 int8_tArray _res_conv_12 = _res_vals[m];
17429 LDKThirtyTwoBytes _res_conv_12_ref;
17430 CHECK(_res_conv_12->arr_len == 32);
17431 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
17432 _res_constr.data[m] = _res_conv_12_ref;
17435 CVec_ThirtyTwoBytesZ_free(_res_constr);
17438 static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
17439 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
17440 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
17441 return tag_ptr(ret_conv, true);
17443 int64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint64_t arg) {
17444 LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(arg);
17445 int64_t ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
17449 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint64_t orig) {
17450 LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(orig);
17451 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
17452 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
17453 return tag_ptr(ret_conv, true);
17456 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_new"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
17457 LDKThirtyTwoBytes a_ref;
17458 CHECK(a->arr_len == 32);
17459 memcpy(a_ref.data, a->elems, 32); FREE(a);
17460 LDKThirtyTwoBytes b_ref;
17461 CHECK(b->arr_len == 32);
17462 memcpy(b_ref.data, b->elems, 32); FREE(b);
17463 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
17464 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
17465 return tag_ptr(ret_conv, true);
17468 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_free"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint64_t _res) {
17469 if (!ptr_is_owned(_res)) return;
17470 void* _res_ptr = untag_ptr(_res);
17471 CHECK_ACCESS(_res_ptr);
17472 LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(_res_ptr);
17473 FREE(untag_ptr(_res));
17474 C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
17477 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(uint64_t o) {
17478 void* o_ptr = untag_ptr(o);
17479 CHECK_ACCESS(o_ptr);
17480 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
17481 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(o));
17482 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17483 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o_conv);
17484 return tag_ptr(ret_conv, true);
17487 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err() {
17488 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17489 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
17490 return tag_ptr(ret_conv, true);
17493 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(uint64_t o) {
17494 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(o);
17495 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o_conv);
17499 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(uint64_t _res) {
17500 if (!ptr_is_owned(_res)) return;
17501 void* _res_ptr = untag_ptr(_res);
17502 CHECK_ACCESS(_res_ptr);
17503 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(_res_ptr);
17504 FREE(untag_ptr(_res));
17505 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res_conv);
17508 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg) {
17509 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17510 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(arg);
17511 return tag_ptr(ret_conv, true);
17513 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(uint64_t arg) {
17514 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(arg);
17515 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg_conv);
17519 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(uint64_t orig) {
17520 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(orig);
17521 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17522 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig_conv);
17523 return tag_ptr(ret_conv, true);
17526 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(uint64_t o) {
17527 void* o_ptr = untag_ptr(o);
17528 CHECK_ACCESS(o_ptr);
17529 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
17530 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(o));
17531 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17532 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o_conv);
17533 return tag_ptr(ret_conv, true);
17536 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(uint64_t e) {
17537 void* e_ptr = untag_ptr(e);
17538 CHECK_ACCESS(e_ptr);
17539 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17540 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17541 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17542 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e_conv);
17543 return tag_ptr(ret_conv, true);
17546 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(uint64_t o) {
17547 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(o);
17548 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o_conv);
17552 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(uint64_t _res) {
17553 if (!ptr_is_owned(_res)) return;
17554 void* _res_ptr = untag_ptr(_res);
17555 CHECK_ACCESS(_res_ptr);
17556 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(_res_ptr);
17557 FREE(untag_ptr(_res));
17558 CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res_conv);
17561 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg) {
17562 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17563 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(arg);
17564 return tag_ptr(ret_conv, true);
17566 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(uint64_t arg) {
17567 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(arg);
17568 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg_conv);
17572 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(uint64_t orig) {
17573 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(orig);
17574 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17575 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig_conv);
17576 return tag_ptr(ret_conv, true);
17579 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_ok"))) TS_CResult_PaymentSecretNoneZ_ok(int8_tArray o) {
17580 LDKThirtyTwoBytes o_ref;
17581 CHECK(o->arr_len == 32);
17582 memcpy(o_ref.data, o->elems, 32); FREE(o);
17583 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17584 *ret_conv = CResult_PaymentSecretNoneZ_ok(o_ref);
17585 return tag_ptr(ret_conv, true);
17588 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_err"))) TS_CResult_PaymentSecretNoneZ_err() {
17589 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17590 *ret_conv = CResult_PaymentSecretNoneZ_err();
17591 return tag_ptr(ret_conv, true);
17594 jboolean __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_is_ok"))) TS_CResult_PaymentSecretNoneZ_is_ok(uint64_t o) {
17595 LDKCResult_PaymentSecretNoneZ* o_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(o);
17596 jboolean ret_conv = CResult_PaymentSecretNoneZ_is_ok(o_conv);
17600 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_free"))) TS_CResult_PaymentSecretNoneZ_free(uint64_t _res) {
17601 if (!ptr_is_owned(_res)) return;
17602 void* _res_ptr = untag_ptr(_res);
17603 CHECK_ACCESS(_res_ptr);
17604 LDKCResult_PaymentSecretNoneZ _res_conv = *(LDKCResult_PaymentSecretNoneZ*)(_res_ptr);
17605 FREE(untag_ptr(_res));
17606 CResult_PaymentSecretNoneZ_free(_res_conv);
17609 static inline uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg) {
17610 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17611 *ret_conv = CResult_PaymentSecretNoneZ_clone(arg);
17612 return tag_ptr(ret_conv, true);
17614 int64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone_ptr"))) TS_CResult_PaymentSecretNoneZ_clone_ptr(uint64_t arg) {
17615 LDKCResult_PaymentSecretNoneZ* arg_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(arg);
17616 int64_t ret_conv = CResult_PaymentSecretNoneZ_clone_ptr(arg_conv);
17620 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone"))) TS_CResult_PaymentSecretNoneZ_clone(uint64_t orig) {
17621 LDKCResult_PaymentSecretNoneZ* orig_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(orig);
17622 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17623 *ret_conv = CResult_PaymentSecretNoneZ_clone(orig_conv);
17624 return tag_ptr(ret_conv, true);
17627 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_ok"))) TS_CResult_PaymentSecretAPIErrorZ_ok(int8_tArray o) {
17628 LDKThirtyTwoBytes o_ref;
17629 CHECK(o->arr_len == 32);
17630 memcpy(o_ref.data, o->elems, 32); FREE(o);
17631 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17632 *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
17633 return tag_ptr(ret_conv, true);
17636 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_err"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint64_t e) {
17637 void* e_ptr = untag_ptr(e);
17638 CHECK_ACCESS(e_ptr);
17639 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17640 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17641 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17642 *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
17643 return tag_ptr(ret_conv, true);
17646 jboolean __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_is_ok"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint64_t o) {
17647 LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(o);
17648 jboolean ret_conv = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
17652 void __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_free"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint64_t _res) {
17653 if (!ptr_is_owned(_res)) return;
17654 void* _res_ptr = untag_ptr(_res);
17655 CHECK_ACCESS(_res_ptr);
17656 LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(_res_ptr);
17657 FREE(untag_ptr(_res));
17658 CResult_PaymentSecretAPIErrorZ_free(_res_conv);
17661 static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
17662 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17663 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
17664 return tag_ptr(ret_conv, true);
17666 int64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone_ptr"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint64_t arg) {
17667 LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(arg);
17668 int64_t ret_conv = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
17672 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint64_t orig) {
17673 LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(orig);
17674 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17675 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
17676 return tag_ptr(ret_conv, true);
17679 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_ok(int8_tArray o) {
17680 LDKThirtyTwoBytes o_ref;
17681 CHECK(o->arr_len == 32);
17682 memcpy(o_ref.data, o->elems, 32); FREE(o);
17683 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17684 *ret_conv = CResult_PaymentPreimageAPIErrorZ_ok(o_ref);
17685 return tag_ptr(ret_conv, true);
17688 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_err"))) TS_CResult_PaymentPreimageAPIErrorZ_err(uint64_t e) {
17689 void* e_ptr = untag_ptr(e);
17690 CHECK_ACCESS(e_ptr);
17691 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17692 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17693 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17694 *ret_conv = CResult_PaymentPreimageAPIErrorZ_err(e_conv);
17695 return tag_ptr(ret_conv, true);
17698 jboolean __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_is_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_is_ok(uint64_t o) {
17699 LDKCResult_PaymentPreimageAPIErrorZ* o_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(o);
17700 jboolean ret_conv = CResult_PaymentPreimageAPIErrorZ_is_ok(o_conv);
17704 void __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_free"))) TS_CResult_PaymentPreimageAPIErrorZ_free(uint64_t _res) {
17705 if (!ptr_is_owned(_res)) return;
17706 void* _res_ptr = untag_ptr(_res);
17707 CHECK_ACCESS(_res_ptr);
17708 LDKCResult_PaymentPreimageAPIErrorZ _res_conv = *(LDKCResult_PaymentPreimageAPIErrorZ*)(_res_ptr);
17709 FREE(untag_ptr(_res));
17710 CResult_PaymentPreimageAPIErrorZ_free(_res_conv);
17713 static inline uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg) {
17714 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17715 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(arg);
17716 return tag_ptr(ret_conv, true);
17718 int64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr"))) TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(uint64_t arg) {
17719 LDKCResult_PaymentPreimageAPIErrorZ* arg_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(arg);
17720 int64_t ret_conv = CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg_conv);
17724 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone"))) TS_CResult_PaymentPreimageAPIErrorZ_clone(uint64_t orig) {
17725 LDKCResult_PaymentPreimageAPIErrorZ* orig_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(orig);
17726 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17727 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(orig_conv);
17728 return tag_ptr(ret_conv, true);
17731 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(uint64_t o) {
17732 LDKCounterpartyForwardingInfo o_conv;
17733 o_conv.inner = untag_ptr(o);
17734 o_conv.is_owned = ptr_is_owned(o);
17735 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17736 o_conv = CounterpartyForwardingInfo_clone(&o_conv);
17737 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17738 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o_conv);
17739 return tag_ptr(ret_conv, true);
17742 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(uint64_t e) {
17743 void* e_ptr = untag_ptr(e);
17744 CHECK_ACCESS(e_ptr);
17745 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17746 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17747 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17748 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e_conv);
17749 return tag_ptr(ret_conv, true);
17752 jboolean __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(uint64_t o) {
17753 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* o_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(o);
17754 jboolean ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o_conv);
17758 void __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(uint64_t _res) {
17759 if (!ptr_is_owned(_res)) return;
17760 void* _res_ptr = untag_ptr(_res);
17761 CHECK_ACCESS(_res_ptr);
17762 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(_res_ptr);
17763 FREE(untag_ptr(_res));
17764 CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res_conv);
17767 static inline uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg) {
17768 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17769 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(arg);
17770 return tag_ptr(ret_conv, true);
17772 int64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
17773 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(arg);
17774 int64_t ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg_conv);
17778 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(uint64_t orig) {
17779 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(orig);
17780 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17781 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig_conv);
17782 return tag_ptr(ret_conv, true);
17785 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(uint64_t o) {
17786 LDKChannelCounterparty o_conv;
17787 o_conv.inner = untag_ptr(o);
17788 o_conv.is_owned = ptr_is_owned(o);
17789 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17790 o_conv = ChannelCounterparty_clone(&o_conv);
17791 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17792 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_ok(o_conv);
17793 return tag_ptr(ret_conv, true);
17796 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_err(uint64_t e) {
17797 void* e_ptr = untag_ptr(e);
17798 CHECK_ACCESS(e_ptr);
17799 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17800 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17801 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17802 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_err(e_conv);
17803 return tag_ptr(ret_conv, true);
17806 jboolean __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(uint64_t o) {
17807 LDKCResult_ChannelCounterpartyDecodeErrorZ* o_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(o);
17808 jboolean ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o_conv);
17812 void __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_free"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_free(uint64_t _res) {
17813 if (!ptr_is_owned(_res)) return;
17814 void* _res_ptr = untag_ptr(_res);
17815 CHECK_ACCESS(_res_ptr);
17816 LDKCResult_ChannelCounterpartyDecodeErrorZ _res_conv = *(LDKCResult_ChannelCounterpartyDecodeErrorZ*)(_res_ptr);
17817 FREE(untag_ptr(_res));
17818 CResult_ChannelCounterpartyDecodeErrorZ_free(_res_conv);
17821 static inline uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg) {
17822 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17823 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(arg);
17824 return tag_ptr(ret_conv, true);
17826 int64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(uint64_t arg) {
17827 LDKCResult_ChannelCounterpartyDecodeErrorZ* arg_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(arg);
17828 int64_t ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg_conv);
17832 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(uint64_t orig) {
17833 LDKCResult_ChannelCounterpartyDecodeErrorZ* orig_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(orig);
17834 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17835 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(orig_conv);
17836 return tag_ptr(ret_conv, true);
17839 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_ok(uint64_t o) {
17840 LDKChannelDetails o_conv;
17841 o_conv.inner = untag_ptr(o);
17842 o_conv.is_owned = ptr_is_owned(o);
17843 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17844 o_conv = ChannelDetails_clone(&o_conv);
17845 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17846 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_ok(o_conv);
17847 return tag_ptr(ret_conv, true);
17850 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_err(uint64_t e) {
17851 void* e_ptr = untag_ptr(e);
17852 CHECK_ACCESS(e_ptr);
17853 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17854 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17855 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17856 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_err(e_conv);
17857 return tag_ptr(ret_conv, true);
17860 jboolean __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_is_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(uint64_t o) {
17861 LDKCResult_ChannelDetailsDecodeErrorZ* o_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(o);
17862 jboolean ret_conv = CResult_ChannelDetailsDecodeErrorZ_is_ok(o_conv);
17866 void __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_free"))) TS_CResult_ChannelDetailsDecodeErrorZ_free(uint64_t _res) {
17867 if (!ptr_is_owned(_res)) return;
17868 void* _res_ptr = untag_ptr(_res);
17869 CHECK_ACCESS(_res_ptr);
17870 LDKCResult_ChannelDetailsDecodeErrorZ _res_conv = *(LDKCResult_ChannelDetailsDecodeErrorZ*)(_res_ptr);
17871 FREE(untag_ptr(_res));
17872 CResult_ChannelDetailsDecodeErrorZ_free(_res_conv);
17875 static inline uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg) {
17876 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17877 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(arg);
17878 return tag_ptr(ret_conv, true);
17880 int64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(uint64_t arg) {
17881 LDKCResult_ChannelDetailsDecodeErrorZ* arg_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(arg);
17882 int64_t ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg_conv);
17886 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone(uint64_t orig) {
17887 LDKCResult_ChannelDetailsDecodeErrorZ* orig_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(orig);
17888 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17889 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(orig_conv);
17890 return tag_ptr(ret_conv, true);
17893 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(uint64_t o) {
17894 LDKPhantomRouteHints o_conv;
17895 o_conv.inner = untag_ptr(o);
17896 o_conv.is_owned = ptr_is_owned(o);
17897 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17898 o_conv = PhantomRouteHints_clone(&o_conv);
17899 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17900 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_ok(o_conv);
17901 return tag_ptr(ret_conv, true);
17904 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_err(uint64_t e) {
17905 void* e_ptr = untag_ptr(e);
17906 CHECK_ACCESS(e_ptr);
17907 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17908 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17909 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17910 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_err(e_conv);
17911 return tag_ptr(ret_conv, true);
17914 jboolean __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(uint64_t o) {
17915 LDKCResult_PhantomRouteHintsDecodeErrorZ* o_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(o);
17916 jboolean ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o_conv);
17920 void __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_free"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_free(uint64_t _res) {
17921 if (!ptr_is_owned(_res)) return;
17922 void* _res_ptr = untag_ptr(_res);
17923 CHECK_ACCESS(_res_ptr);
17924 LDKCResult_PhantomRouteHintsDecodeErrorZ _res_conv = *(LDKCResult_PhantomRouteHintsDecodeErrorZ*)(_res_ptr);
17925 FREE(untag_ptr(_res));
17926 CResult_PhantomRouteHintsDecodeErrorZ_free(_res_conv);
17929 static inline uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg) {
17930 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17931 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(arg);
17932 return tag_ptr(ret_conv, true);
17934 int64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(uint64_t arg) {
17935 LDKCResult_PhantomRouteHintsDecodeErrorZ* arg_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(arg);
17936 int64_t ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg_conv);
17940 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(uint64_t orig) {
17941 LDKCResult_PhantomRouteHintsDecodeErrorZ* orig_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(orig);
17942 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17943 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(orig_conv);
17944 return tag_ptr(ret_conv, true);
17947 void __attribute__((export_name("TS_CVec_ChannelMonitorZ_free"))) TS_CVec_ChannelMonitorZ_free(uint64_tArray _res) {
17948 LDKCVec_ChannelMonitorZ _res_constr;
17949 _res_constr.datalen = _res->arr_len;
17950 if (_res_constr.datalen > 0)
17951 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
17953 _res_constr.data = NULL;
17954 uint64_t* _res_vals = _res->elems;
17955 for (size_t q = 0; q < _res_constr.datalen; q++) {
17956 uint64_t _res_conv_16 = _res_vals[q];
17957 LDKChannelMonitor _res_conv_16_conv;
17958 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
17959 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
17960 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
17961 _res_constr.data[q] = _res_conv_16_conv;
17964 CVec_ChannelMonitorZ_free(_res_constr);
17967 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_new"))) TS_C2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint64_t b) {
17968 LDKThirtyTwoBytes a_ref;
17969 CHECK(a->arr_len == 32);
17970 memcpy(a_ref.data, a->elems, 32); FREE(a);
17971 LDKChannelManager b_conv;
17972 b_conv.inner = untag_ptr(b);
17973 b_conv.is_owned = ptr_is_owned(b);
17974 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
17975 // WARNING: we need a move here but no clone is available for LDKChannelManager
17977 LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
17978 *ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
17979 return tag_ptr(ret_conv, true);
17982 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_free"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint64_t _res) {
17983 if (!ptr_is_owned(_res)) return;
17984 void* _res_ptr = untag_ptr(_res);
17985 CHECK_ACCESS(_res_ptr);
17986 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(_res_ptr);
17987 FREE(untag_ptr(_res));
17988 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
17991 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint64_t o) {
17992 void* o_ptr = untag_ptr(o);
17993 CHECK_ACCESS(o_ptr);
17994 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(o_ptr);
17995 // WARNING: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ
17996 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
17997 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
17998 return tag_ptr(ret_conv, true);
18001 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(uint64_t e) {
18002 void* e_ptr = untag_ptr(e);
18003 CHECK_ACCESS(e_ptr);
18004 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18005 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18006 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
18007 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
18008 return tag_ptr(ret_conv, true);
18011 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint64_t o) {
18012 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(o);
18013 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
18017 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint64_t _res) {
18018 if (!ptr_is_owned(_res)) return;
18019 void* _res_ptr = untag_ptr(_res);
18020 CHECK_ACCESS(_res_ptr);
18021 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(_res_ptr);
18022 FREE(untag_ptr(_res));
18023 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
18026 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint64_t o) {
18027 LDKChannelConfig o_conv;
18028 o_conv.inner = untag_ptr(o);
18029 o_conv.is_owned = ptr_is_owned(o);
18030 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18031 o_conv = ChannelConfig_clone(&o_conv);
18032 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18033 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
18034 return tag_ptr(ret_conv, true);
18037 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_err"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint64_t e) {
18038 void* e_ptr = untag_ptr(e);
18039 CHECK_ACCESS(e_ptr);
18040 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18041 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18042 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18043 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
18044 return tag_ptr(ret_conv, true);
18047 jboolean __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_is_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint64_t o) {
18048 LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(o);
18049 jboolean ret_conv = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
18053 void __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_free"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint64_t _res) {
18054 if (!ptr_is_owned(_res)) return;
18055 void* _res_ptr = untag_ptr(_res);
18056 CHECK_ACCESS(_res_ptr);
18057 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(_res_ptr);
18058 FREE(untag_ptr(_res));
18059 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
18062 static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
18063 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18064 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
18065 return tag_ptr(ret_conv, true);
18067 int64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint64_t arg) {
18068 LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(arg);
18069 int64_t ret_conv = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
18073 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint64_t orig) {
18074 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(orig);
18075 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18076 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
18077 return tag_ptr(ret_conv, true);
18080 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_some"))) TS_COption_APIErrorZ_some(uint64_t o) {
18081 void* o_ptr = untag_ptr(o);
18082 CHECK_ACCESS(o_ptr);
18083 LDKAPIError o_conv = *(LDKAPIError*)(o_ptr);
18084 o_conv = APIError_clone((LDKAPIError*)untag_ptr(o));
18085 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18086 *ret_copy = COption_APIErrorZ_some(o_conv);
18087 uint64_t ret_ref = tag_ptr(ret_copy, true);
18091 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_none"))) TS_COption_APIErrorZ_none() {
18092 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18093 *ret_copy = COption_APIErrorZ_none();
18094 uint64_t ret_ref = tag_ptr(ret_copy, true);
18098 void __attribute__((export_name("TS_COption_APIErrorZ_free"))) TS_COption_APIErrorZ_free(uint64_t _res) {
18099 if (!ptr_is_owned(_res)) return;
18100 void* _res_ptr = untag_ptr(_res);
18101 CHECK_ACCESS(_res_ptr);
18102 LDKCOption_APIErrorZ _res_conv = *(LDKCOption_APIErrorZ*)(_res_ptr);
18103 FREE(untag_ptr(_res));
18104 COption_APIErrorZ_free(_res_conv);
18107 static inline uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg) {
18108 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18109 *ret_copy = COption_APIErrorZ_clone(arg);
18110 uint64_t ret_ref = tag_ptr(ret_copy, true);
18113 int64_t __attribute__((export_name("TS_COption_APIErrorZ_clone_ptr"))) TS_COption_APIErrorZ_clone_ptr(uint64_t arg) {
18114 LDKCOption_APIErrorZ* arg_conv = (LDKCOption_APIErrorZ*)untag_ptr(arg);
18115 int64_t ret_conv = COption_APIErrorZ_clone_ptr(arg_conv);
18119 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_clone"))) TS_COption_APIErrorZ_clone(uint64_t orig) {
18120 LDKCOption_APIErrorZ* orig_conv = (LDKCOption_APIErrorZ*)untag_ptr(orig);
18121 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18122 *ret_copy = COption_APIErrorZ_clone(orig_conv);
18123 uint64_t ret_ref = tag_ptr(ret_copy, true);
18127 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_ok(uint64_t o) {
18128 void* o_ptr = untag_ptr(o);
18129 CHECK_ACCESS(o_ptr);
18130 LDKCOption_APIErrorZ o_conv = *(LDKCOption_APIErrorZ*)(o_ptr);
18131 o_conv = COption_APIErrorZ_clone((LDKCOption_APIErrorZ*)untag_ptr(o));
18132 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18133 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_ok(o_conv);
18134 return tag_ptr(ret_conv, true);
18137 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_err"))) TS_CResult_COption_APIErrorZDecodeErrorZ_err(uint64_t e) {
18138 void* e_ptr = untag_ptr(e);
18139 CHECK_ACCESS(e_ptr);
18140 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18141 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18142 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18143 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_err(e_conv);
18144 return tag_ptr(ret_conv, true);
18147 jboolean __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(uint64_t o) {
18148 LDKCResult_COption_APIErrorZDecodeErrorZ* o_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(o);
18149 jboolean ret_conv = CResult_COption_APIErrorZDecodeErrorZ_is_ok(o_conv);
18153 void __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_free"))) TS_CResult_COption_APIErrorZDecodeErrorZ_free(uint64_t _res) {
18154 if (!ptr_is_owned(_res)) return;
18155 void* _res_ptr = untag_ptr(_res);
18156 CHECK_ACCESS(_res_ptr);
18157 LDKCResult_COption_APIErrorZDecodeErrorZ _res_conv = *(LDKCResult_COption_APIErrorZDecodeErrorZ*)(_res_ptr);
18158 FREE(untag_ptr(_res));
18159 CResult_COption_APIErrorZDecodeErrorZ_free(_res_conv);
18162 static inline uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg) {
18163 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18164 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone(arg);
18165 return tag_ptr(ret_conv, true);
18167 int64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(uint64_t arg) {
18168 LDKCResult_COption_APIErrorZDecodeErrorZ* arg_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(arg);
18169 int64_t ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg_conv);
18173 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_clone"))) TS_CResult_COption_APIErrorZDecodeErrorZ_clone(uint64_t orig) {
18174 LDKCResult_COption_APIErrorZDecodeErrorZ* orig_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(orig);
18175 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18176 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone(orig_conv);
18177 return tag_ptr(ret_conv, true);
18180 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_ok(uint64_t o) {
18181 LDKUntrustedString o_conv;
18182 o_conv.inner = untag_ptr(o);
18183 o_conv.is_owned = ptr_is_owned(o);
18184 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18185 o_conv = UntrustedString_clone(&o_conv);
18186 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18187 *ret_conv = CResult_UntrustedStringDecodeErrorZ_ok(o_conv);
18188 return tag_ptr(ret_conv, true);
18191 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_err"))) TS_CResult_UntrustedStringDecodeErrorZ_err(uint64_t e) {
18192 void* e_ptr = untag_ptr(e);
18193 CHECK_ACCESS(e_ptr);
18194 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18195 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18196 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18197 *ret_conv = CResult_UntrustedStringDecodeErrorZ_err(e_conv);
18198 return tag_ptr(ret_conv, true);
18201 jboolean __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_is_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_is_ok(uint64_t o) {
18202 LDKCResult_UntrustedStringDecodeErrorZ* o_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(o);
18203 jboolean ret_conv = CResult_UntrustedStringDecodeErrorZ_is_ok(o_conv);
18207 void __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_free"))) TS_CResult_UntrustedStringDecodeErrorZ_free(uint64_t _res) {
18208 if (!ptr_is_owned(_res)) return;
18209 void* _res_ptr = untag_ptr(_res);
18210 CHECK_ACCESS(_res_ptr);
18211 LDKCResult_UntrustedStringDecodeErrorZ _res_conv = *(LDKCResult_UntrustedStringDecodeErrorZ*)(_res_ptr);
18212 FREE(untag_ptr(_res));
18213 CResult_UntrustedStringDecodeErrorZ_free(_res_conv);
18216 static inline uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg) {
18217 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18218 *ret_conv = CResult_UntrustedStringDecodeErrorZ_clone(arg);
18219 return tag_ptr(ret_conv, true);
18221 int64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr"))) TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(uint64_t arg) {
18222 LDKCResult_UntrustedStringDecodeErrorZ* arg_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(arg);
18223 int64_t ret_conv = CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg_conv);
18227 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_clone"))) TS_CResult_UntrustedStringDecodeErrorZ_clone(uint64_t orig) {
18228 LDKCResult_UntrustedStringDecodeErrorZ* orig_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(orig);
18229 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18230 *ret_conv = CResult_UntrustedStringDecodeErrorZ_clone(orig_conv);
18231 return tag_ptr(ret_conv, true);
18234 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_ok"))) TS_CResult_OutPointDecodeErrorZ_ok(uint64_t o) {
18235 LDKOutPoint o_conv;
18236 o_conv.inner = untag_ptr(o);
18237 o_conv.is_owned = ptr_is_owned(o);
18238 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18239 o_conv = OutPoint_clone(&o_conv);
18240 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18241 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
18242 return tag_ptr(ret_conv, true);
18245 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_err"))) TS_CResult_OutPointDecodeErrorZ_err(uint64_t e) {
18246 void* e_ptr = untag_ptr(e);
18247 CHECK_ACCESS(e_ptr);
18248 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18249 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18250 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18251 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
18252 return tag_ptr(ret_conv, true);
18255 jboolean __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_is_ok"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint64_t o) {
18256 LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(o);
18257 jboolean ret_conv = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
18261 void __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_free"))) TS_CResult_OutPointDecodeErrorZ_free(uint64_t _res) {
18262 if (!ptr_is_owned(_res)) return;
18263 void* _res_ptr = untag_ptr(_res);
18264 CHECK_ACCESS(_res_ptr);
18265 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(_res_ptr);
18266 FREE(untag_ptr(_res));
18267 CResult_OutPointDecodeErrorZ_free(_res_conv);
18270 static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
18271 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18272 *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
18273 return tag_ptr(ret_conv, true);
18275 int64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone_ptr"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint64_t arg) {
18276 LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(arg);
18277 int64_t ret_conv = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
18281 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone"))) TS_CResult_OutPointDecodeErrorZ_clone(uint64_t orig) {
18282 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(orig);
18283 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18284 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
18285 return tag_ptr(ret_conv, true);
18288 uint64_t __attribute__((export_name("TS_COption_TypeZ_some"))) TS_COption_TypeZ_some(uint64_t o) {
18289 void* o_ptr = untag_ptr(o);
18290 CHECK_ACCESS(o_ptr);
18291 LDKType o_conv = *(LDKType*)(o_ptr);
18292 if (o_conv.free == LDKType_JCalls_free) {
18293 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
18294 LDKType_JCalls_cloned(&o_conv);
18296 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18297 *ret_copy = COption_TypeZ_some(o_conv);
18298 uint64_t ret_ref = tag_ptr(ret_copy, true);
18302 uint64_t __attribute__((export_name("TS_COption_TypeZ_none"))) TS_COption_TypeZ_none() {
18303 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18304 *ret_copy = COption_TypeZ_none();
18305 uint64_t ret_ref = tag_ptr(ret_copy, true);
18309 void __attribute__((export_name("TS_COption_TypeZ_free"))) TS_COption_TypeZ_free(uint64_t _res) {
18310 if (!ptr_is_owned(_res)) return;
18311 void* _res_ptr = untag_ptr(_res);
18312 CHECK_ACCESS(_res_ptr);
18313 LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(_res_ptr);
18314 FREE(untag_ptr(_res));
18315 COption_TypeZ_free(_res_conv);
18318 static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
18319 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18320 *ret_copy = COption_TypeZ_clone(arg);
18321 uint64_t ret_ref = tag_ptr(ret_copy, true);
18324 int64_t __attribute__((export_name("TS_COption_TypeZ_clone_ptr"))) TS_COption_TypeZ_clone_ptr(uint64_t arg) {
18325 LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)untag_ptr(arg);
18326 int64_t ret_conv = COption_TypeZ_clone_ptr(arg_conv);
18330 uint64_t __attribute__((export_name("TS_COption_TypeZ_clone"))) TS_COption_TypeZ_clone(uint64_t orig) {
18331 LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)untag_ptr(orig);
18332 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18333 *ret_copy = COption_TypeZ_clone(orig_conv);
18334 uint64_t ret_ref = tag_ptr(ret_copy, true);
18338 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint64_t o) {
18339 void* o_ptr = untag_ptr(o);
18340 CHECK_ACCESS(o_ptr);
18341 LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(o_ptr);
18342 o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)untag_ptr(o));
18343 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18344 *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv);
18345 return tag_ptr(ret_conv, true);
18348 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_err"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint64_t e) {
18349 void* e_ptr = untag_ptr(e);
18350 CHECK_ACCESS(e_ptr);
18351 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18352 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18353 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18354 *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
18355 return tag_ptr(ret_conv, true);
18358 jboolean __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_is_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint64_t o) {
18359 LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(o);
18360 jboolean ret_conv = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
18364 void __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_free"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint64_t _res) {
18365 if (!ptr_is_owned(_res)) return;
18366 void* _res_ptr = untag_ptr(_res);
18367 CHECK_ACCESS(_res_ptr);
18368 LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(_res_ptr);
18369 FREE(untag_ptr(_res));
18370 CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
18373 static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
18374 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18375 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
18376 return tag_ptr(ret_conv, true);
18378 int64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint64_t arg) {
18379 LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(arg);
18380 int64_t ret_conv = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
18384 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint64_t orig) {
18385 LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(orig);
18386 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18387 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv);
18388 return tag_ptr(ret_conv, true);
18391 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_ok"))) TS_CResult_PaymentIdPaymentErrorZ_ok(int8_tArray o) {
18392 LDKThirtyTwoBytes o_ref;
18393 CHECK(o->arr_len == 32);
18394 memcpy(o_ref.data, o->elems, 32); FREE(o);
18395 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18396 *ret_conv = CResult_PaymentIdPaymentErrorZ_ok(o_ref);
18397 return tag_ptr(ret_conv, true);
18400 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_err"))) TS_CResult_PaymentIdPaymentErrorZ_err(uint64_t e) {
18401 void* e_ptr = untag_ptr(e);
18402 CHECK_ACCESS(e_ptr);
18403 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
18404 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
18405 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18406 *ret_conv = CResult_PaymentIdPaymentErrorZ_err(e_conv);
18407 return tag_ptr(ret_conv, true);
18410 jboolean __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_is_ok"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint64_t o) {
18411 LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(o);
18412 jboolean ret_conv = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
18416 void __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_free"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint64_t _res) {
18417 if (!ptr_is_owned(_res)) return;
18418 void* _res_ptr = untag_ptr(_res);
18419 CHECK_ACCESS(_res_ptr);
18420 LDKCResult_PaymentIdPaymentErrorZ _res_conv = *(LDKCResult_PaymentIdPaymentErrorZ*)(_res_ptr);
18421 FREE(untag_ptr(_res));
18422 CResult_PaymentIdPaymentErrorZ_free(_res_conv);
18425 static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
18426 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18427 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
18428 return tag_ptr(ret_conv, true);
18430 int64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone_ptr"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint64_t arg) {
18431 LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(arg);
18432 int64_t ret_conv = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
18436 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint64_t orig) {
18437 LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(orig);
18438 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18439 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(orig_conv);
18440 return tag_ptr(ret_conv, true);
18443 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_ok"))) TS_CResult_NonePaymentErrorZ_ok() {
18444 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18445 *ret_conv = CResult_NonePaymentErrorZ_ok();
18446 return tag_ptr(ret_conv, true);
18449 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_err"))) TS_CResult_NonePaymentErrorZ_err(uint64_t e) {
18450 void* e_ptr = untag_ptr(e);
18451 CHECK_ACCESS(e_ptr);
18452 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
18453 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
18454 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18455 *ret_conv = CResult_NonePaymentErrorZ_err(e_conv);
18456 return tag_ptr(ret_conv, true);
18459 jboolean __attribute__((export_name("TS_CResult_NonePaymentErrorZ_is_ok"))) TS_CResult_NonePaymentErrorZ_is_ok(uint64_t o) {
18460 LDKCResult_NonePaymentErrorZ* o_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(o);
18461 jboolean ret_conv = CResult_NonePaymentErrorZ_is_ok(o_conv);
18465 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_free"))) TS_CResult_NonePaymentErrorZ_free(uint64_t _res) {
18466 if (!ptr_is_owned(_res)) return;
18467 void* _res_ptr = untag_ptr(_res);
18468 CHECK_ACCESS(_res_ptr);
18469 LDKCResult_NonePaymentErrorZ _res_conv = *(LDKCResult_NonePaymentErrorZ*)(_res_ptr);
18470 FREE(untag_ptr(_res));
18471 CResult_NonePaymentErrorZ_free(_res_conv);
18474 static inline uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg) {
18475 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18476 *ret_conv = CResult_NonePaymentErrorZ_clone(arg);
18477 return tag_ptr(ret_conv, true);
18479 int64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone_ptr"))) TS_CResult_NonePaymentErrorZ_clone_ptr(uint64_t arg) {
18480 LDKCResult_NonePaymentErrorZ* arg_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(arg);
18481 int64_t ret_conv = CResult_NonePaymentErrorZ_clone_ptr(arg_conv);
18485 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone"))) TS_CResult_NonePaymentErrorZ_clone(uint64_t orig) {
18486 LDKCResult_NonePaymentErrorZ* orig_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(orig);
18487 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18488 *ret_conv = CResult_NonePaymentErrorZ_clone(orig_conv);
18489 return tag_ptr(ret_conv, true);
18492 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_ok"))) TS_CResult_StringErrorZ_ok(jstring o) {
18493 LDKStr o_conv = str_ref_to_owned_c(o);
18494 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18495 *ret_conv = CResult_StringErrorZ_ok(o_conv);
18496 return tag_ptr(ret_conv, true);
18499 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_err"))) TS_CResult_StringErrorZ_err(uint32_t e) {
18500 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
18501 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18502 *ret_conv = CResult_StringErrorZ_err(e_conv);
18503 return tag_ptr(ret_conv, true);
18506 jboolean __attribute__((export_name("TS_CResult_StringErrorZ_is_ok"))) TS_CResult_StringErrorZ_is_ok(uint64_t o) {
18507 LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)untag_ptr(o);
18508 jboolean ret_conv = CResult_StringErrorZ_is_ok(o_conv);
18512 void __attribute__((export_name("TS_CResult_StringErrorZ_free"))) TS_CResult_StringErrorZ_free(uint64_t _res) {
18513 if (!ptr_is_owned(_res)) return;
18514 void* _res_ptr = untag_ptr(_res);
18515 CHECK_ACCESS(_res_ptr);
18516 LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(_res_ptr);
18517 FREE(untag_ptr(_res));
18518 CResult_StringErrorZ_free(_res_conv);
18521 static inline uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg) {
18522 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18523 *ret_conv = CResult_StringErrorZ_clone(arg);
18524 return tag_ptr(ret_conv, true);
18526 int64_t __attribute__((export_name("TS_CResult_StringErrorZ_clone_ptr"))) TS_CResult_StringErrorZ_clone_ptr(uint64_t arg) {
18527 LDKCResult_StringErrorZ* arg_conv = (LDKCResult_StringErrorZ*)untag_ptr(arg);
18528 int64_t ret_conv = CResult_StringErrorZ_clone_ptr(arg_conv);
18532 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_clone"))) TS_CResult_StringErrorZ_clone(uint64_t orig) {
18533 LDKCResult_StringErrorZ* orig_conv = (LDKCResult_StringErrorZ*)untag_ptr(orig);
18534 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18535 *ret_conv = CResult_StringErrorZ_clone(orig_conv);
18536 return tag_ptr(ret_conv, true);
18539 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint64_t o) {
18540 LDKChannelMonitorUpdate o_conv;
18541 o_conv.inner = untag_ptr(o);
18542 o_conv.is_owned = ptr_is_owned(o);
18543 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18544 o_conv = ChannelMonitorUpdate_clone(&o_conv);
18545 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18546 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
18547 return tag_ptr(ret_conv, true);
18550 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint64_t e) {
18551 void* e_ptr = untag_ptr(e);
18552 CHECK_ACCESS(e_ptr);
18553 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18554 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18555 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18556 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
18557 return tag_ptr(ret_conv, true);
18560 jboolean __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint64_t o) {
18561 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(o);
18562 jboolean ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
18566 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint64_t _res) {
18567 if (!ptr_is_owned(_res)) return;
18568 void* _res_ptr = untag_ptr(_res);
18569 CHECK_ACCESS(_res_ptr);
18570 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(_res_ptr);
18571 FREE(untag_ptr(_res));
18572 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
18575 static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
18576 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18577 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
18578 return tag_ptr(ret_conv, true);
18580 int64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
18581 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(arg);
18582 int64_t ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
18586 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint64_t orig) {
18587 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(orig);
18588 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18589 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
18590 return tag_ptr(ret_conv, true);
18593 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_some"))) TS_COption_MonitorEventZ_some(uint64_t o) {
18594 void* o_ptr = untag_ptr(o);
18595 CHECK_ACCESS(o_ptr);
18596 LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
18597 o_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(o));
18598 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18599 *ret_copy = COption_MonitorEventZ_some(o_conv);
18600 uint64_t ret_ref = tag_ptr(ret_copy, true);
18604 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_none"))) TS_COption_MonitorEventZ_none() {
18605 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18606 *ret_copy = COption_MonitorEventZ_none();
18607 uint64_t ret_ref = tag_ptr(ret_copy, true);
18611 void __attribute__((export_name("TS_COption_MonitorEventZ_free"))) TS_COption_MonitorEventZ_free(uint64_t _res) {
18612 if (!ptr_is_owned(_res)) return;
18613 void* _res_ptr = untag_ptr(_res);
18614 CHECK_ACCESS(_res_ptr);
18615 LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
18616 FREE(untag_ptr(_res));
18617 COption_MonitorEventZ_free(_res_conv);
18620 static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
18621 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18622 *ret_copy = COption_MonitorEventZ_clone(arg);
18623 uint64_t ret_ref = tag_ptr(ret_copy, true);
18626 int64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone_ptr"))) TS_COption_MonitorEventZ_clone_ptr(uint64_t arg) {
18627 LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)untag_ptr(arg);
18628 int64_t ret_conv = COption_MonitorEventZ_clone_ptr(arg_conv);
18632 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone"))) TS_COption_MonitorEventZ_clone(uint64_t orig) {
18633 LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)untag_ptr(orig);
18634 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18635 *ret_copy = COption_MonitorEventZ_clone(orig_conv);
18636 uint64_t ret_ref = tag_ptr(ret_copy, true);
18640 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint64_t o) {
18641 void* o_ptr = untag_ptr(o);
18642 CHECK_ACCESS(o_ptr);
18643 LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
18644 o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)untag_ptr(o));
18645 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18646 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
18647 return tag_ptr(ret_conv, true);
18650 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint64_t e) {
18651 void* e_ptr = untag_ptr(e);
18652 CHECK_ACCESS(e_ptr);
18653 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18654 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18655 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18656 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
18657 return tag_ptr(ret_conv, true);
18660 jboolean __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint64_t o) {
18661 LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(o);
18662 jboolean ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
18666 void __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_free"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint64_t _res) {
18667 if (!ptr_is_owned(_res)) return;
18668 void* _res_ptr = untag_ptr(_res);
18669 CHECK_ACCESS(_res_ptr);
18670 LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
18671 FREE(untag_ptr(_res));
18672 CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
18675 static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
18676 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18677 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
18678 return tag_ptr(ret_conv, true);
18680 int64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint64_t arg) {
18681 LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(arg);
18682 int64_t ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
18686 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint64_t orig) {
18687 LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(orig);
18688 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18689 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
18690 return tag_ptr(ret_conv, true);
18693 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint64_t o) {
18694 LDKHTLCUpdate o_conv;
18695 o_conv.inner = untag_ptr(o);
18696 o_conv.is_owned = ptr_is_owned(o);
18697 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18698 o_conv = HTLCUpdate_clone(&o_conv);
18699 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18700 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
18701 return tag_ptr(ret_conv, true);
18704 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint64_t e) {
18705 void* e_ptr = untag_ptr(e);
18706 CHECK_ACCESS(e_ptr);
18707 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18708 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18709 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18710 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
18711 return tag_ptr(ret_conv, true);
18714 jboolean __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_is_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint64_t o) {
18715 LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(o);
18716 jboolean ret_conv = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
18720 void __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_free"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint64_t _res) {
18721 if (!ptr_is_owned(_res)) return;
18722 void* _res_ptr = untag_ptr(_res);
18723 CHECK_ACCESS(_res_ptr);
18724 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(_res_ptr);
18725 FREE(untag_ptr(_res));
18726 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
18729 static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
18730 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18731 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
18732 return tag_ptr(ret_conv, true);
18734 int64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
18735 LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(arg);
18736 int64_t ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
18740 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint64_t orig) {
18741 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(orig);
18742 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18743 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
18744 return tag_ptr(ret_conv, true);
18747 static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
18748 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
18749 *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
18750 return tag_ptr(ret_conv, true);
18752 int64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone_ptr"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint64_t arg) {
18753 LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(arg);
18754 int64_t ret_conv = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
18758 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone"))) TS_C2Tuple_OutPointScriptZ_clone(uint64_t orig) {
18759 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(orig);
18760 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
18761 *ret_conv = C2Tuple_OutPointScriptZ_clone(orig_conv);
18762 return tag_ptr(ret_conv, true);
18765 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_new"))) TS_C2Tuple_OutPointScriptZ_new(uint64_t a, int8_tArray b) {
18766 LDKOutPoint a_conv;
18767 a_conv.inner = untag_ptr(a);
18768 a_conv.is_owned = ptr_is_owned(a);
18769 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
18770 a_conv = OutPoint_clone(&a_conv);
18772 b_ref.datalen = b->arr_len;
18773 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
18774 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
18775 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
18776 *ret_conv = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
18777 return tag_ptr(ret_conv, true);
18780 void __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_free"))) TS_C2Tuple_OutPointScriptZ_free(uint64_t _res) {
18781 if (!ptr_is_owned(_res)) return;
18782 void* _res_ptr = untag_ptr(_res);
18783 CHECK_ACCESS(_res_ptr);
18784 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(_res_ptr);
18785 FREE(untag_ptr(_res));
18786 C2Tuple_OutPointScriptZ_free(_res_conv);
18789 static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
18790 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18791 *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
18792 return tag_ptr(ret_conv, true);
18794 int64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone_ptr"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint64_t arg) {
18795 LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(arg);
18796 int64_t ret_conv = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
18800 uint64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone"))) TS_C2Tuple_u32ScriptZ_clone(uint64_t orig) {
18801 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(orig);
18802 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18803 *ret_conv = C2Tuple_u32ScriptZ_clone(orig_conv);
18804 return tag_ptr(ret_conv, true);
18807 uint64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_new"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
18809 b_ref.datalen = b->arr_len;
18810 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
18811 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
18812 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18813 *ret_conv = C2Tuple_u32ScriptZ_new(a, b_ref);
18814 return tag_ptr(ret_conv, true);
18817 void __attribute__((export_name("TS_C2Tuple_u32ScriptZ_free"))) TS_C2Tuple_u32ScriptZ_free(uint64_t _res) {
18818 if (!ptr_is_owned(_res)) return;
18819 void* _res_ptr = untag_ptr(_res);
18820 CHECK_ACCESS(_res_ptr);
18821 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_ptr);
18822 FREE(untag_ptr(_res));
18823 C2Tuple_u32ScriptZ_free(_res_conv);
18826 void __attribute__((export_name("TS_CVec_C2Tuple_u32ScriptZZ_free"))) TS_CVec_C2Tuple_u32ScriptZZ_free(uint64_tArray _res) {
18827 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
18828 _res_constr.datalen = _res->arr_len;
18829 if (_res_constr.datalen > 0)
18830 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
18832 _res_constr.data = NULL;
18833 uint64_t* _res_vals = _res->elems;
18834 for (size_t v = 0; v < _res_constr.datalen; v++) {
18835 uint64_t _res_conv_21 = _res_vals[v];
18836 void* _res_conv_21_ptr = untag_ptr(_res_conv_21);
18837 CHECK_ACCESS(_res_conv_21_ptr);
18838 LDKC2Tuple_u32ScriptZ _res_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_conv_21_ptr);
18839 FREE(untag_ptr(_res_conv_21));
18840 _res_constr.data[v] = _res_conv_21_conv;
18843 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
18846 static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
18847 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18848 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
18849 return tag_ptr(ret_conv, true);
18851 int64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint64_t arg) {
18852 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(arg);
18853 int64_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
18857 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint64_t orig) {
18858 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(orig);
18859 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18860 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
18861 return tag_ptr(ret_conv, true);
18864 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint64_tArray b) {
18865 LDKThirtyTwoBytes a_ref;
18866 CHECK(a->arr_len == 32);
18867 memcpy(a_ref.data, a->elems, 32); FREE(a);
18868 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
18869 b_constr.datalen = b->arr_len;
18870 if (b_constr.datalen > 0)
18871 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
18873 b_constr.data = NULL;
18874 uint64_t* b_vals = b->elems;
18875 for (size_t v = 0; v < b_constr.datalen; v++) {
18876 uint64_t b_conv_21 = b_vals[v];
18877 void* b_conv_21_ptr = untag_ptr(b_conv_21);
18878 CHECK_ACCESS(b_conv_21_ptr);
18879 LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(b_conv_21_ptr);
18880 b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)untag_ptr(b_conv_21));
18881 b_constr.data[v] = b_conv_21_conv;
18884 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18885 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
18886 return tag_ptr(ret_conv, true);
18889 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint64_t _res) {
18890 if (!ptr_is_owned(_res)) return;
18891 void* _res_ptr = untag_ptr(_res);
18892 CHECK_ACCESS(_res_ptr);
18893 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_ptr);
18894 FREE(untag_ptr(_res));
18895 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
18898 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(uint64_tArray _res) {
18899 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
18900 _res_constr.datalen = _res->arr_len;
18901 if (_res_constr.datalen > 0)
18902 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
18904 _res_constr.data = NULL;
18905 uint64_t* _res_vals = _res->elems;
18906 for (size_t o = 0; o < _res_constr.datalen; o++) {
18907 uint64_t _res_conv_40 = _res_vals[o];
18908 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
18909 CHECK_ACCESS(_res_conv_40_ptr);
18910 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_40_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_conv_40_ptr);
18911 FREE(untag_ptr(_res_conv_40));
18912 _res_constr.data[o] = _res_conv_40_conv;
18915 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
18918 void __attribute__((export_name("TS_CVec_EventZ_free"))) TS_CVec_EventZ_free(uint64_tArray _res) {
18919 LDKCVec_EventZ _res_constr;
18920 _res_constr.datalen = _res->arr_len;
18921 if (_res_constr.datalen > 0)
18922 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
18924 _res_constr.data = NULL;
18925 uint64_t* _res_vals = _res->elems;
18926 for (size_t h = 0; h < _res_constr.datalen; h++) {
18927 uint64_t _res_conv_7 = _res_vals[h];
18928 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
18929 CHECK_ACCESS(_res_conv_7_ptr);
18930 LDKEvent _res_conv_7_conv = *(LDKEvent*)(_res_conv_7_ptr);
18931 FREE(untag_ptr(_res_conv_7));
18932 _res_constr.data[h] = _res_conv_7_conv;
18935 CVec_EventZ_free(_res_constr);
18938 void __attribute__((export_name("TS_CVec_TransactionZ_free"))) TS_CVec_TransactionZ_free(ptrArray _res) {
18939 LDKCVec_TransactionZ _res_constr;
18940 _res_constr.datalen = _res->arr_len;
18941 if (_res_constr.datalen > 0)
18942 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
18944 _res_constr.data = NULL;
18945 int8_tArray* _res_vals = (void*) _res->elems;
18946 for (size_t m = 0; m < _res_constr.datalen; m++) {
18947 int8_tArray _res_conv_12 = _res_vals[m];
18948 LDKTransaction _res_conv_12_ref;
18949 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
18950 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
18951 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
18952 _res_conv_12_ref.data_is_owned = true;
18953 _res_constr.data[m] = _res_conv_12_ref;
18956 CVec_TransactionZ_free(_res_constr);
18959 static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
18960 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18961 *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
18962 return tag_ptr(ret_conv, true);
18964 int64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone_ptr"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint64_t arg) {
18965 LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(arg);
18966 int64_t ret_conv = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
18970 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone"))) TS_C2Tuple_u32TxOutZ_clone(uint64_t orig) {
18971 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(orig);
18972 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18973 *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv);
18974 return tag_ptr(ret_conv, true);
18977 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_new"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint64_t b) {
18978 void* b_ptr = untag_ptr(b);
18979 CHECK_ACCESS(b_ptr);
18980 LDKTxOut b_conv = *(LDKTxOut*)(b_ptr);
18981 b_conv = TxOut_clone((LDKTxOut*)untag_ptr(b));
18982 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18983 *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv);
18984 return tag_ptr(ret_conv, true);
18987 void __attribute__((export_name("TS_C2Tuple_u32TxOutZ_free"))) TS_C2Tuple_u32TxOutZ_free(uint64_t _res) {
18988 if (!ptr_is_owned(_res)) return;
18989 void* _res_ptr = untag_ptr(_res);
18990 CHECK_ACCESS(_res_ptr);
18991 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_ptr);
18992 FREE(untag_ptr(_res));
18993 C2Tuple_u32TxOutZ_free(_res_conv);
18996 void __attribute__((export_name("TS_CVec_C2Tuple_u32TxOutZZ_free"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint64_tArray _res) {
18997 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
18998 _res_constr.datalen = _res->arr_len;
18999 if (_res_constr.datalen > 0)
19000 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
19002 _res_constr.data = NULL;
19003 uint64_t* _res_vals = _res->elems;
19004 for (size_t u = 0; u < _res_constr.datalen; u++) {
19005 uint64_t _res_conv_20 = _res_vals[u];
19006 void* _res_conv_20_ptr = untag_ptr(_res_conv_20);
19007 CHECK_ACCESS(_res_conv_20_ptr);
19008 LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_conv_20_ptr);
19009 FREE(untag_ptr(_res_conv_20));
19010 _res_constr.data[u] = _res_conv_20_conv;
19013 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
19016 static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
19017 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
19018 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
19019 return tag_ptr(ret_conv, true);
19021 int64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint64_t arg) {
19022 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(arg);
19023 int64_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
19027 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint64_t orig) {
19028 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(orig);
19029 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
19030 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
19031 return tag_ptr(ret_conv, true);
19034 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint64_tArray b) {
19035 LDKThirtyTwoBytes a_ref;
19036 CHECK(a->arr_len == 32);
19037 memcpy(a_ref.data, a->elems, 32); FREE(a);
19038 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
19039 b_constr.datalen = b->arr_len;
19040 if (b_constr.datalen > 0)
19041 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
19043 b_constr.data = NULL;
19044 uint64_t* b_vals = b->elems;
19045 for (size_t u = 0; u < b_constr.datalen; u++) {
19046 uint64_t b_conv_20 = b_vals[u];
19047 void* b_conv_20_ptr = untag_ptr(b_conv_20);
19048 CHECK_ACCESS(b_conv_20_ptr);
19049 LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(b_conv_20_ptr);
19050 b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)untag_ptr(b_conv_20));
19051 b_constr.data[u] = b_conv_20_conv;
19054 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
19055 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
19056 return tag_ptr(ret_conv, true);
19059 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint64_t _res) {
19060 if (!ptr_is_owned(_res)) return;
19061 void* _res_ptr = untag_ptr(_res);
19062 CHECK_ACCESS(_res_ptr);
19063 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_ptr);
19064 FREE(untag_ptr(_res));
19065 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
19068 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(uint64_tArray _res) {
19069 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
19070 _res_constr.datalen = _res->arr_len;
19071 if (_res_constr.datalen > 0)
19072 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
19074 _res_constr.data = NULL;
19075 uint64_t* _res_vals = _res->elems;
19076 for (size_t n = 0; n < _res_constr.datalen; n++) {
19077 uint64_t _res_conv_39 = _res_vals[n];
19078 void* _res_conv_39_ptr = untag_ptr(_res_conv_39);
19079 CHECK_ACCESS(_res_conv_39_ptr);
19080 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_39_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_conv_39_ptr);
19081 FREE(untag_ptr(_res_conv_39));
19082 _res_constr.data[n] = _res_conv_39_conv;
19085 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
19088 void __attribute__((export_name("TS_CVec_BalanceZ_free"))) TS_CVec_BalanceZ_free(uint64_tArray _res) {
19089 LDKCVec_BalanceZ _res_constr;
19090 _res_constr.datalen = _res->arr_len;
19091 if (_res_constr.datalen > 0)
19092 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements");
19094 _res_constr.data = NULL;
19095 uint64_t* _res_vals = _res->elems;
19096 for (size_t j = 0; j < _res_constr.datalen; j++) {
19097 uint64_t _res_conv_9 = _res_vals[j];
19098 void* _res_conv_9_ptr = untag_ptr(_res_conv_9);
19099 CHECK_ACCESS(_res_conv_9_ptr);
19100 LDKBalance _res_conv_9_conv = *(LDKBalance*)(_res_conv_9_ptr);
19101 FREE(untag_ptr(_res_conv_9));
19102 _res_constr.data[j] = _res_conv_9_conv;
19105 CVec_BalanceZ_free(_res_constr);
19108 static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
19109 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
19110 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
19111 return tag_ptr(ret_conv, true);
19113 int64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint64_t arg) {
19114 LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(arg);
19115 int64_t ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
19119 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint64_t orig) {
19120 LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(orig);
19121 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
19122 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(orig_conv);
19123 return tag_ptr(ret_conv, true);
19126 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_new"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint64_t b) {
19127 LDKThirtyTwoBytes a_ref;
19128 CHECK(a->arr_len == 32);
19129 memcpy(a_ref.data, a->elems, 32); FREE(a);
19130 LDKChannelMonitor b_conv;
19131 b_conv.inner = untag_ptr(b);
19132 b_conv.is_owned = ptr_is_owned(b);
19133 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
19134 b_conv = ChannelMonitor_clone(&b_conv);
19135 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
19136 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
19137 return tag_ptr(ret_conv, true);
19140 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_free"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint64_t _res) {
19141 if (!ptr_is_owned(_res)) return;
19142 void* _res_ptr = untag_ptr(_res);
19143 CHECK_ACCESS(_res_ptr);
19144 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(_res_ptr);
19145 FREE(untag_ptr(_res));
19146 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
19149 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint64_t o) {
19150 void* o_ptr = untag_ptr(o);
19151 CHECK_ACCESS(o_ptr);
19152 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(o_ptr);
19153 o_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(o));
19154 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19155 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
19156 return tag_ptr(ret_conv, true);
19159 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(uint64_t e) {
19160 void* e_ptr = untag_ptr(e);
19161 CHECK_ACCESS(e_ptr);
19162 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19163 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19164 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19165 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
19166 return tag_ptr(ret_conv, true);
19169 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint64_t o) {
19170 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(o);
19171 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
19175 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint64_t _res) {
19176 if (!ptr_is_owned(_res)) return;
19177 void* _res_ptr = untag_ptr(_res);
19178 CHECK_ACCESS(_res_ptr);
19179 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(_res_ptr);
19180 FREE(untag_ptr(_res));
19181 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
19184 static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
19185 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19186 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
19187 return tag_ptr(ret_conv, true);
19189 int64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint64_t arg) {
19190 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(arg);
19191 int64_t ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
19195 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint64_t orig) {
19196 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(orig);
19197 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19198 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig_conv);
19199 return tag_ptr(ret_conv, true);
19202 static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
19203 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
19204 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
19205 return tag_ptr(ret_conv, true);
19207 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone_ptr"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint64_t arg) {
19208 LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(arg);
19209 int64_t ret_conv = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
19213 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint64_t orig) {
19214 LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(orig);
19215 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
19216 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv);
19217 return tag_ptr(ret_conv, true);
19220 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_new"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint64_t b) {
19221 LDKPublicKey a_ref;
19222 CHECK(a->arr_len == 33);
19223 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
19224 void* b_ptr = untag_ptr(b);
19225 CHECK_ACCESS(b_ptr);
19226 LDKType b_conv = *(LDKType*)(b_ptr);
19227 if (b_conv.free == LDKType_JCalls_free) {
19228 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19229 LDKType_JCalls_cloned(&b_conv);
19231 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
19232 *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv);
19233 return tag_ptr(ret_conv, true);
19236 void __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_free"))) TS_C2Tuple_PublicKeyTypeZ_free(uint64_t _res) {
19237 if (!ptr_is_owned(_res)) return;
19238 void* _res_ptr = untag_ptr(_res);
19239 CHECK_ACCESS(_res_ptr);
19240 LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_ptr);
19241 FREE(untag_ptr(_res));
19242 C2Tuple_PublicKeyTypeZ_free(_res_conv);
19245 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyTypeZZ_free"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint64_tArray _res) {
19246 LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr;
19247 _res_constr.datalen = _res->arr_len;
19248 if (_res_constr.datalen > 0)
19249 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
19251 _res_constr.data = NULL;
19252 uint64_t* _res_vals = _res->elems;
19253 for (size_t z = 0; z < _res_constr.datalen; z++) {
19254 uint64_t _res_conv_25 = _res_vals[z];
19255 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
19256 CHECK_ACCESS(_res_conv_25_ptr);
19257 LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_conv_25_ptr);
19258 FREE(untag_ptr(_res_conv_25));
19259 _res_constr.data[z] = _res_conv_25_conv;
19262 CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr);
19265 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_some"))) TS_COption_CustomOnionMessageContentsZ_some(uint64_t o) {
19266 void* o_ptr = untag_ptr(o);
19267 CHECK_ACCESS(o_ptr);
19268 LDKCustomOnionMessageContents o_conv = *(LDKCustomOnionMessageContents*)(o_ptr);
19269 if (o_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
19270 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19271 LDKCustomOnionMessageContents_JCalls_cloned(&o_conv);
19273 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19274 *ret_copy = COption_CustomOnionMessageContentsZ_some(o_conv);
19275 uint64_t ret_ref = tag_ptr(ret_copy, true);
19279 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_none"))) TS_COption_CustomOnionMessageContentsZ_none() {
19280 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19281 *ret_copy = COption_CustomOnionMessageContentsZ_none();
19282 uint64_t ret_ref = tag_ptr(ret_copy, true);
19286 void __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_free"))) TS_COption_CustomOnionMessageContentsZ_free(uint64_t _res) {
19287 if (!ptr_is_owned(_res)) return;
19288 void* _res_ptr = untag_ptr(_res);
19289 CHECK_ACCESS(_res_ptr);
19290 LDKCOption_CustomOnionMessageContentsZ _res_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(_res_ptr);
19291 FREE(untag_ptr(_res));
19292 COption_CustomOnionMessageContentsZ_free(_res_conv);
19295 static inline uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg) {
19296 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19297 *ret_copy = COption_CustomOnionMessageContentsZ_clone(arg);
19298 uint64_t ret_ref = tag_ptr(ret_copy, true);
19301 int64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone_ptr"))) TS_COption_CustomOnionMessageContentsZ_clone_ptr(uint64_t arg) {
19302 LDKCOption_CustomOnionMessageContentsZ* arg_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(arg);
19303 int64_t ret_conv = COption_CustomOnionMessageContentsZ_clone_ptr(arg_conv);
19307 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone"))) TS_COption_CustomOnionMessageContentsZ_clone(uint64_t orig) {
19308 LDKCOption_CustomOnionMessageContentsZ* orig_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(orig);
19309 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19310 *ret_copy = COption_CustomOnionMessageContentsZ_clone(orig_conv);
19311 uint64_t ret_ref = tag_ptr(ret_copy, true);
19315 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(uint64_t o) {
19316 void* o_ptr = untag_ptr(o);
19317 CHECK_ACCESS(o_ptr);
19318 LDKCOption_CustomOnionMessageContentsZ o_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(o_ptr);
19319 o_conv = COption_CustomOnionMessageContentsZ_clone((LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(o));
19320 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19321 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o_conv);
19322 return tag_ptr(ret_conv, true);
19325 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(uint64_t e) {
19326 void* e_ptr = untag_ptr(e);
19327 CHECK_ACCESS(e_ptr);
19328 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19329 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19330 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19331 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e_conv);
19332 return tag_ptr(ret_conv, true);
19335 jboolean __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(uint64_t o) {
19336 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* o_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(o);
19337 jboolean ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o_conv);
19341 void __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(uint64_t _res) {
19342 if (!ptr_is_owned(_res)) return;
19343 void* _res_ptr = untag_ptr(_res);
19344 CHECK_ACCESS(_res_ptr);
19345 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(_res_ptr);
19346 FREE(untag_ptr(_res));
19347 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res_conv);
19350 static inline uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg) {
19351 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19352 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(arg);
19353 return tag_ptr(ret_conv, true);
19355 int64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(uint64_t arg) {
19356 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* arg_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(arg);
19357 int64_t ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg_conv);
19361 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(uint64_t orig) {
19362 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* orig_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(orig);
19363 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19364 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig_conv);
19365 return tag_ptr(ret_conv, true);
19368 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_some"))) TS_COption_NetAddressZ_some(uint64_t o) {
19369 void* o_ptr = untag_ptr(o);
19370 CHECK_ACCESS(o_ptr);
19371 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
19372 o_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o));
19373 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19374 *ret_copy = COption_NetAddressZ_some(o_conv);
19375 uint64_t ret_ref = tag_ptr(ret_copy, true);
19379 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_none"))) TS_COption_NetAddressZ_none() {
19380 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19381 *ret_copy = COption_NetAddressZ_none();
19382 uint64_t ret_ref = tag_ptr(ret_copy, true);
19386 void __attribute__((export_name("TS_COption_NetAddressZ_free"))) TS_COption_NetAddressZ_free(uint64_t _res) {
19387 if (!ptr_is_owned(_res)) return;
19388 void* _res_ptr = untag_ptr(_res);
19389 CHECK_ACCESS(_res_ptr);
19390 LDKCOption_NetAddressZ _res_conv = *(LDKCOption_NetAddressZ*)(_res_ptr);
19391 FREE(untag_ptr(_res));
19392 COption_NetAddressZ_free(_res_conv);
19395 static inline uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg) {
19396 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19397 *ret_copy = COption_NetAddressZ_clone(arg);
19398 uint64_t ret_ref = tag_ptr(ret_copy, true);
19401 int64_t __attribute__((export_name("TS_COption_NetAddressZ_clone_ptr"))) TS_COption_NetAddressZ_clone_ptr(uint64_t arg) {
19402 LDKCOption_NetAddressZ* arg_conv = (LDKCOption_NetAddressZ*)untag_ptr(arg);
19403 int64_t ret_conv = COption_NetAddressZ_clone_ptr(arg_conv);
19407 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_clone"))) TS_COption_NetAddressZ_clone(uint64_t orig) {
19408 LDKCOption_NetAddressZ* orig_conv = (LDKCOption_NetAddressZ*)untag_ptr(orig);
19409 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19410 *ret_copy = COption_NetAddressZ_clone(orig_conv);
19411 uint64_t ret_ref = tag_ptr(ret_copy, true);
19415 static inline uint64_t C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR arg) {
19416 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
19417 *ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_clone(arg);
19418 return tag_ptr(ret_conv, true);
19420 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(uint64_t arg) {
19421 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* arg_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(arg);
19422 int64_t ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(arg_conv);
19426 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone(uint64_t orig) {
19427 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* orig_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(orig);
19428 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
19429 *ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_clone(orig_conv);
19430 return tag_ptr(ret_conv, true);
19433 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_new"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_new(int8_tArray a, uint64_t b) {
19434 LDKPublicKey a_ref;
19435 CHECK(a->arr_len == 33);
19436 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
19437 void* b_ptr = untag_ptr(b);
19438 CHECK_ACCESS(b_ptr);
19439 LDKCOption_NetAddressZ b_conv = *(LDKCOption_NetAddressZ*)(b_ptr);
19440 b_conv = COption_NetAddressZ_clone((LDKCOption_NetAddressZ*)untag_ptr(b));
19441 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
19442 *ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_new(a_ref, b_conv);
19443 return tag_ptr(ret_conv, true);
19446 void __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_free"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_free(uint64_t _res) {
19447 if (!ptr_is_owned(_res)) return;
19448 void* _res_ptr = untag_ptr(_res);
19449 CHECK_ACCESS(_res_ptr);
19450 LDKC2Tuple_PublicKeyCOption_NetAddressZZ _res_conv = *(LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)(_res_ptr);
19451 FREE(untag_ptr(_res));
19452 C2Tuple_PublicKeyCOption_NetAddressZZ_free(_res_conv);
19455 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free"))) TS_CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(uint64_tArray _res) {
19456 LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ _res_constr;
19457 _res_constr.datalen = _res->arr_len;
19458 if (_res_constr.datalen > 0)
19459 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ Elements");
19461 _res_constr.data = NULL;
19462 uint64_t* _res_vals = _res->elems;
19463 for (size_t o = 0; o < _res_constr.datalen; o++) {
19464 uint64_t _res_conv_40 = _res_vals[o];
19465 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
19466 CHECK_ACCESS(_res_conv_40_ptr);
19467 LDKC2Tuple_PublicKeyCOption_NetAddressZZ _res_conv_40_conv = *(LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)(_res_conv_40_ptr);
19468 FREE(untag_ptr(_res_conv_40));
19469 _res_constr.data[o] = _res_conv_40_conv;
19472 CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(_res_constr);
19475 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
19477 o_ref.datalen = o->arr_len;
19478 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
19479 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
19480 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19481 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
19482 return tag_ptr(ret_conv, true);
19485 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint64_t e) {
19486 LDKPeerHandleError e_conv;
19487 e_conv.inner = untag_ptr(e);
19488 e_conv.is_owned = ptr_is_owned(e);
19489 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19490 e_conv = PeerHandleError_clone(&e_conv);
19491 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19492 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
19493 return tag_ptr(ret_conv, true);
19496 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint64_t o) {
19497 LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(o);
19498 jboolean ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
19502 void __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_free"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint64_t _res) {
19503 if (!ptr_is_owned(_res)) return;
19504 void* _res_ptr = untag_ptr(_res);
19505 CHECK_ACCESS(_res_ptr);
19506 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(_res_ptr);
19507 FREE(untag_ptr(_res));
19508 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
19511 static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
19512 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19513 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
19514 return tag_ptr(ret_conv, true);
19516 int64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint64_t arg) {
19517 LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(arg);
19518 int64_t ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
19522 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint64_t orig) {
19523 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(orig);
19524 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19525 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
19526 return tag_ptr(ret_conv, true);
19529 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_ok"))) TS_CResult_NonePeerHandleErrorZ_ok() {
19530 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19531 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
19532 return tag_ptr(ret_conv, true);
19535 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_err"))) TS_CResult_NonePeerHandleErrorZ_err(uint64_t e) {
19536 LDKPeerHandleError e_conv;
19537 e_conv.inner = untag_ptr(e);
19538 e_conv.is_owned = ptr_is_owned(e);
19539 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19540 e_conv = PeerHandleError_clone(&e_conv);
19541 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19542 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
19543 return tag_ptr(ret_conv, true);
19546 jboolean __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_is_ok"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint64_t o) {
19547 LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(o);
19548 jboolean ret_conv = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
19552 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_free"))) TS_CResult_NonePeerHandleErrorZ_free(uint64_t _res) {
19553 if (!ptr_is_owned(_res)) return;
19554 void* _res_ptr = untag_ptr(_res);
19555 CHECK_ACCESS(_res_ptr);
19556 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(_res_ptr);
19557 FREE(untag_ptr(_res));
19558 CResult_NonePeerHandleErrorZ_free(_res_conv);
19561 static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
19562 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19563 *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
19564 return tag_ptr(ret_conv, true);
19566 int64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone_ptr"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint64_t arg) {
19567 LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(arg);
19568 int64_t ret_conv = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
19572 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone"))) TS_CResult_NonePeerHandleErrorZ_clone(uint64_t orig) {
19573 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(orig);
19574 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19575 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
19576 return tag_ptr(ret_conv, true);
19579 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_ok"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
19580 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19581 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
19582 return tag_ptr(ret_conv, true);
19585 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_err"))) TS_CResult_boolPeerHandleErrorZ_err(uint64_t e) {
19586 LDKPeerHandleError e_conv;
19587 e_conv.inner = untag_ptr(e);
19588 e_conv.is_owned = ptr_is_owned(e);
19589 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19590 e_conv = PeerHandleError_clone(&e_conv);
19591 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19592 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
19593 return tag_ptr(ret_conv, true);
19596 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_is_ok"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint64_t o) {
19597 LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(o);
19598 jboolean ret_conv = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
19602 void __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_free"))) TS_CResult_boolPeerHandleErrorZ_free(uint64_t _res) {
19603 if (!ptr_is_owned(_res)) return;
19604 void* _res_ptr = untag_ptr(_res);
19605 CHECK_ACCESS(_res_ptr);
19606 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(_res_ptr);
19607 FREE(untag_ptr(_res));
19608 CResult_boolPeerHandleErrorZ_free(_res_conv);
19611 static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
19612 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19613 *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
19614 return tag_ptr(ret_conv, true);
19616 int64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone_ptr"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint64_t arg) {
19617 LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(arg);
19618 int64_t ret_conv = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
19622 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone"))) TS_CResult_boolPeerHandleErrorZ_clone(uint64_t orig) {
19623 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(orig);
19624 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19625 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
19626 return tag_ptr(ret_conv, true);
19629 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_ok(uint64_t o) {
19630 void* o_ptr = untag_ptr(o);
19631 CHECK_ACCESS(o_ptr);
19632 LDKTxOut o_conv = *(LDKTxOut*)(o_ptr);
19633 o_conv = TxOut_clone((LDKTxOut*)untag_ptr(o));
19634 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19635 *ret_conv = CResult_TxOutUtxoLookupErrorZ_ok(o_conv);
19636 return tag_ptr(ret_conv, true);
19639 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_err"))) TS_CResult_TxOutUtxoLookupErrorZ_err(uint32_t e) {
19640 LDKUtxoLookupError e_conv = LDKUtxoLookupError_from_js(e);
19641 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19642 *ret_conv = CResult_TxOutUtxoLookupErrorZ_err(e_conv);
19643 return tag_ptr(ret_conv, true);
19646 jboolean __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_is_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_is_ok(uint64_t o) {
19647 LDKCResult_TxOutUtxoLookupErrorZ* o_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(o);
19648 jboolean ret_conv = CResult_TxOutUtxoLookupErrorZ_is_ok(o_conv);
19652 void __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_free"))) TS_CResult_TxOutUtxoLookupErrorZ_free(uint64_t _res) {
19653 if (!ptr_is_owned(_res)) return;
19654 void* _res_ptr = untag_ptr(_res);
19655 CHECK_ACCESS(_res_ptr);
19656 LDKCResult_TxOutUtxoLookupErrorZ _res_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(_res_ptr);
19657 FREE(untag_ptr(_res));
19658 CResult_TxOutUtxoLookupErrorZ_free(_res_conv);
19661 static inline uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg) {
19662 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19663 *ret_conv = CResult_TxOutUtxoLookupErrorZ_clone(arg);
19664 return tag_ptr(ret_conv, true);
19666 int64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr"))) TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(uint64_t arg) {
19667 LDKCResult_TxOutUtxoLookupErrorZ* arg_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(arg);
19668 int64_t ret_conv = CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg_conv);
19672 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_clone"))) TS_CResult_TxOutUtxoLookupErrorZ_clone(uint64_t orig) {
19673 LDKCResult_TxOutUtxoLookupErrorZ* orig_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(orig);
19674 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19675 *ret_conv = CResult_TxOutUtxoLookupErrorZ_clone(orig_conv);
19676 return tag_ptr(ret_conv, true);
19679 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_ok"))) TS_CResult_NoneSendErrorZ_ok() {
19680 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
19681 *ret_conv = CResult_NoneSendErrorZ_ok();
19682 return tag_ptr(ret_conv, true);
19685 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_err"))) TS_CResult_NoneSendErrorZ_err(uint64_t e) {
19686 void* e_ptr = untag_ptr(e);
19687 CHECK_ACCESS(e_ptr);
19688 LDKSendError e_conv = *(LDKSendError*)(e_ptr);
19689 e_conv = SendError_clone((LDKSendError*)untag_ptr(e));
19690 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
19691 *ret_conv = CResult_NoneSendErrorZ_err(e_conv);
19692 return tag_ptr(ret_conv, true);
19695 jboolean __attribute__((export_name("TS_CResult_NoneSendErrorZ_is_ok"))) TS_CResult_NoneSendErrorZ_is_ok(uint64_t o) {
19696 LDKCResult_NoneSendErrorZ* o_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(o);
19697 jboolean ret_conv = CResult_NoneSendErrorZ_is_ok(o_conv);
19701 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_free"))) TS_CResult_NoneSendErrorZ_free(uint64_t _res) {
19702 if (!ptr_is_owned(_res)) return;
19703 void* _res_ptr = untag_ptr(_res);
19704 CHECK_ACCESS(_res_ptr);
19705 LDKCResult_NoneSendErrorZ _res_conv = *(LDKCResult_NoneSendErrorZ*)(_res_ptr);
19706 FREE(untag_ptr(_res));
19707 CResult_NoneSendErrorZ_free(_res_conv);
19710 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_ok"))) TS_CResult_BlindedPathNoneZ_ok(uint64_t o) {
19711 LDKBlindedPath o_conv;
19712 o_conv.inner = untag_ptr(o);
19713 o_conv.is_owned = ptr_is_owned(o);
19714 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19715 o_conv = BlindedPath_clone(&o_conv);
19716 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19717 *ret_conv = CResult_BlindedPathNoneZ_ok(o_conv);
19718 return tag_ptr(ret_conv, true);
19721 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_err"))) TS_CResult_BlindedPathNoneZ_err() {
19722 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19723 *ret_conv = CResult_BlindedPathNoneZ_err();
19724 return tag_ptr(ret_conv, true);
19727 jboolean __attribute__((export_name("TS_CResult_BlindedPathNoneZ_is_ok"))) TS_CResult_BlindedPathNoneZ_is_ok(uint64_t o) {
19728 LDKCResult_BlindedPathNoneZ* o_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(o);
19729 jboolean ret_conv = CResult_BlindedPathNoneZ_is_ok(o_conv);
19733 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_free"))) TS_CResult_BlindedPathNoneZ_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_BlindedPathNoneZ _res_conv = *(LDKCResult_BlindedPathNoneZ*)(_res_ptr);
19738 FREE(untag_ptr(_res));
19739 CResult_BlindedPathNoneZ_free(_res_conv);
19742 static inline uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg) {
19743 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19744 *ret_conv = CResult_BlindedPathNoneZ_clone(arg);
19745 return tag_ptr(ret_conv, true);
19747 int64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone_ptr"))) TS_CResult_BlindedPathNoneZ_clone_ptr(uint64_t arg) {
19748 LDKCResult_BlindedPathNoneZ* arg_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(arg);
19749 int64_t ret_conv = CResult_BlindedPathNoneZ_clone_ptr(arg_conv);
19753 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone"))) TS_CResult_BlindedPathNoneZ_clone(uint64_t orig) {
19754 LDKCResult_BlindedPathNoneZ* orig_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(orig);
19755 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19756 *ret_conv = CResult_BlindedPathNoneZ_clone(orig_conv);
19757 return tag_ptr(ret_conv, true);
19760 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_ok"))) TS_CResult_BlindedPathDecodeErrorZ_ok(uint64_t o) {
19761 LDKBlindedPath 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 = BlindedPath_clone(&o_conv);
19766 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19767 *ret_conv = CResult_BlindedPathDecodeErrorZ_ok(o_conv);
19768 return tag_ptr(ret_conv, true);
19771 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_err"))) TS_CResult_BlindedPathDecodeErrorZ_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_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19777 *ret_conv = CResult_BlindedPathDecodeErrorZ_err(e_conv);
19778 return tag_ptr(ret_conv, true);
19781 jboolean __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_is_ok"))) TS_CResult_BlindedPathDecodeErrorZ_is_ok(uint64_t o) {
19782 LDKCResult_BlindedPathDecodeErrorZ* o_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(o);
19783 jboolean ret_conv = CResult_BlindedPathDecodeErrorZ_is_ok(o_conv);
19787 void __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_free"))) TS_CResult_BlindedPathDecodeErrorZ_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_BlindedPathDecodeErrorZ _res_conv = *(LDKCResult_BlindedPathDecodeErrorZ*)(_res_ptr);
19792 FREE(untag_ptr(_res));
19793 CResult_BlindedPathDecodeErrorZ_free(_res_conv);
19796 static inline uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg) {
19797 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19798 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(arg);
19799 return tag_ptr(ret_conv, true);
19801 int64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(uint64_t arg) {
19802 LDKCResult_BlindedPathDecodeErrorZ* arg_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(arg);
19803 int64_t ret_conv = CResult_BlindedPathDecodeErrorZ_clone_ptr(arg_conv);
19807 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone"))) TS_CResult_BlindedPathDecodeErrorZ_clone(uint64_t orig) {
19808 LDKCResult_BlindedPathDecodeErrorZ* orig_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(orig);
19809 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19810 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(orig_conv);
19811 return tag_ptr(ret_conv, true);
19814 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_ok"))) TS_CResult_BlindedHopDecodeErrorZ_ok(uint64_t o) {
19815 LDKBlindedHop 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 = BlindedHop_clone(&o_conv);
19820 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19821 *ret_conv = CResult_BlindedHopDecodeErrorZ_ok(o_conv);
19822 return tag_ptr(ret_conv, true);
19825 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_err"))) TS_CResult_BlindedHopDecodeErrorZ_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_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19831 *ret_conv = CResult_BlindedHopDecodeErrorZ_err(e_conv);
19832 return tag_ptr(ret_conv, true);
19835 jboolean __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopDecodeErrorZ_is_ok(uint64_t o) {
19836 LDKCResult_BlindedHopDecodeErrorZ* o_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(o);
19837 jboolean ret_conv = CResult_BlindedHopDecodeErrorZ_is_ok(o_conv);
19841 void __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_free"))) TS_CResult_BlindedHopDecodeErrorZ_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_BlindedHopDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopDecodeErrorZ*)(_res_ptr);
19846 FREE(untag_ptr(_res));
19847 CResult_BlindedHopDecodeErrorZ_free(_res_conv);
19850 static inline uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg) {
19851 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19852 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(arg);
19853 return tag_ptr(ret_conv, true);
19855 int64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(uint64_t arg) {
19856 LDKCResult_BlindedHopDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(arg);
19857 int64_t ret_conv = CResult_BlindedHopDecodeErrorZ_clone_ptr(arg_conv);
19861 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone"))) TS_CResult_BlindedHopDecodeErrorZ_clone(uint64_t orig) {
19862 LDKCResult_BlindedHopDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(orig);
19863 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19864 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(orig_conv);
19865 return tag_ptr(ret_conv, true);
19868 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_ok"))) TS_CResult_u32GraphSyncErrorZ_ok(int32_t o) {
19869 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
19870 *ret_conv = CResult_u32GraphSyncErrorZ_ok(o);
19871 return tag_ptr(ret_conv, true);
19874 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_err"))) TS_CResult_u32GraphSyncErrorZ_err(uint64_t e) {
19875 void* e_ptr = untag_ptr(e);
19876 CHECK_ACCESS(e_ptr);
19877 LDKGraphSyncError e_conv = *(LDKGraphSyncError*)(e_ptr);
19878 e_conv = GraphSyncError_clone((LDKGraphSyncError*)untag_ptr(e));
19879 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
19880 *ret_conv = CResult_u32GraphSyncErrorZ_err(e_conv);
19881 return tag_ptr(ret_conv, true);
19884 jboolean __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_is_ok"))) TS_CResult_u32GraphSyncErrorZ_is_ok(uint64_t o) {
19885 LDKCResult_u32GraphSyncErrorZ* o_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(o);
19886 jboolean ret_conv = CResult_u32GraphSyncErrorZ_is_ok(o_conv);
19890 void __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_free"))) TS_CResult_u32GraphSyncErrorZ_free(uint64_t _res) {
19891 if (!ptr_is_owned(_res)) return;
19892 void* _res_ptr = untag_ptr(_res);
19893 CHECK_ACCESS(_res_ptr);
19894 LDKCResult_u32GraphSyncErrorZ _res_conv = *(LDKCResult_u32GraphSyncErrorZ*)(_res_ptr);
19895 FREE(untag_ptr(_res));
19896 CResult_u32GraphSyncErrorZ_free(_res_conv);
19899 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_ok"))) TS_CResult_NoneErrorZ_ok() {
19900 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19901 *ret_conv = CResult_NoneErrorZ_ok();
19902 return tag_ptr(ret_conv, true);
19905 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_err"))) TS_CResult_NoneErrorZ_err(uint32_t e) {
19906 LDKIOError e_conv = LDKIOError_from_js(e);
19907 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19908 *ret_conv = CResult_NoneErrorZ_err(e_conv);
19909 return tag_ptr(ret_conv, true);
19912 jboolean __attribute__((export_name("TS_CResult_NoneErrorZ_is_ok"))) TS_CResult_NoneErrorZ_is_ok(uint64_t o) {
19913 LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)untag_ptr(o);
19914 jboolean ret_conv = CResult_NoneErrorZ_is_ok(o_conv);
19918 void __attribute__((export_name("TS_CResult_NoneErrorZ_free"))) TS_CResult_NoneErrorZ_free(uint64_t _res) {
19919 if (!ptr_is_owned(_res)) return;
19920 void* _res_ptr = untag_ptr(_res);
19921 CHECK_ACCESS(_res_ptr);
19922 LDKCResult_NoneErrorZ _res_conv = *(LDKCResult_NoneErrorZ*)(_res_ptr);
19923 FREE(untag_ptr(_res));
19924 CResult_NoneErrorZ_free(_res_conv);
19927 static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
19928 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19929 *ret_conv = CResult_NoneErrorZ_clone(arg);
19930 return tag_ptr(ret_conv, true);
19932 int64_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone_ptr"))) TS_CResult_NoneErrorZ_clone_ptr(uint64_t arg) {
19933 LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)untag_ptr(arg);
19934 int64_t ret_conv = CResult_NoneErrorZ_clone_ptr(arg_conv);
19938 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone"))) TS_CResult_NoneErrorZ_clone(uint64_t orig) {
19939 LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)untag_ptr(orig);
19940 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19941 *ret_conv = CResult_NoneErrorZ_clone(orig_conv);
19942 return tag_ptr(ret_conv, true);
19945 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_ok"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint64_t o) {
19946 void* o_ptr = untag_ptr(o);
19947 CHECK_ACCESS(o_ptr);
19948 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
19949 o_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o));
19950 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19951 *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
19952 return tag_ptr(ret_conv, true);
19955 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_err"))) TS_CResult_NetAddressDecodeErrorZ_err(uint64_t e) {
19956 void* e_ptr = untag_ptr(e);
19957 CHECK_ACCESS(e_ptr);
19958 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19959 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19960 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19961 *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
19962 return tag_ptr(ret_conv, true);
19965 jboolean __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_is_ok"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint64_t o) {
19966 LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(o);
19967 jboolean ret_conv = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
19971 void __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_free"))) TS_CResult_NetAddressDecodeErrorZ_free(uint64_t _res) {
19972 if (!ptr_is_owned(_res)) return;
19973 void* _res_ptr = untag_ptr(_res);
19974 CHECK_ACCESS(_res_ptr);
19975 LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(_res_ptr);
19976 FREE(untag_ptr(_res));
19977 CResult_NetAddressDecodeErrorZ_free(_res_conv);
19980 static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
19981 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19982 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
19983 return tag_ptr(ret_conv, true);
19985 int64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone_ptr"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint64_t arg) {
19986 LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(arg);
19987 int64_t ret_conv = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
19991 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint64_t orig) {
19992 LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(orig);
19993 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19994 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
19995 return tag_ptr(ret_conv, true);
19998 void __attribute__((export_name("TS_CVec_UpdateAddHTLCZ_free"))) TS_CVec_UpdateAddHTLCZ_free(uint64_tArray _res) {
19999 LDKCVec_UpdateAddHTLCZ _res_constr;
20000 _res_constr.datalen = _res->arr_len;
20001 if (_res_constr.datalen > 0)
20002 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
20004 _res_constr.data = NULL;
20005 uint64_t* _res_vals = _res->elems;
20006 for (size_t p = 0; p < _res_constr.datalen; p++) {
20007 uint64_t _res_conv_15 = _res_vals[p];
20008 LDKUpdateAddHTLC _res_conv_15_conv;
20009 _res_conv_15_conv.inner = untag_ptr(_res_conv_15);
20010 _res_conv_15_conv.is_owned = ptr_is_owned(_res_conv_15);
20011 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
20012 _res_constr.data[p] = _res_conv_15_conv;
20015 CVec_UpdateAddHTLCZ_free(_res_constr);
20018 void __attribute__((export_name("TS_CVec_UpdateFulfillHTLCZ_free"))) TS_CVec_UpdateFulfillHTLCZ_free(uint64_tArray _res) {
20019 LDKCVec_UpdateFulfillHTLCZ _res_constr;
20020 _res_constr.datalen = _res->arr_len;
20021 if (_res_constr.datalen > 0)
20022 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
20024 _res_constr.data = NULL;
20025 uint64_t* _res_vals = _res->elems;
20026 for (size_t t = 0; t < _res_constr.datalen; t++) {
20027 uint64_t _res_conv_19 = _res_vals[t];
20028 LDKUpdateFulfillHTLC _res_conv_19_conv;
20029 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
20030 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
20031 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
20032 _res_constr.data[t] = _res_conv_19_conv;
20035 CVec_UpdateFulfillHTLCZ_free(_res_constr);
20038 void __attribute__((export_name("TS_CVec_UpdateFailHTLCZ_free"))) TS_CVec_UpdateFailHTLCZ_free(uint64_tArray _res) {
20039 LDKCVec_UpdateFailHTLCZ _res_constr;
20040 _res_constr.datalen = _res->arr_len;
20041 if (_res_constr.datalen > 0)
20042 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
20044 _res_constr.data = NULL;
20045 uint64_t* _res_vals = _res->elems;
20046 for (size_t q = 0; q < _res_constr.datalen; q++) {
20047 uint64_t _res_conv_16 = _res_vals[q];
20048 LDKUpdateFailHTLC _res_conv_16_conv;
20049 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
20050 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
20051 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
20052 _res_constr.data[q] = _res_conv_16_conv;
20055 CVec_UpdateFailHTLCZ_free(_res_constr);
20058 void __attribute__((export_name("TS_CVec_UpdateFailMalformedHTLCZ_free"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint64_tArray _res) {
20059 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
20060 _res_constr.datalen = _res->arr_len;
20061 if (_res_constr.datalen > 0)
20062 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
20064 _res_constr.data = NULL;
20065 uint64_t* _res_vals = _res->elems;
20066 for (size_t z = 0; z < _res_constr.datalen; z++) {
20067 uint64_t _res_conv_25 = _res_vals[z];
20068 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
20069 _res_conv_25_conv.inner = untag_ptr(_res_conv_25);
20070 _res_conv_25_conv.is_owned = ptr_is_owned(_res_conv_25);
20071 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
20072 _res_constr.data[z] = _res_conv_25_conv;
20075 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
20078 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint64_t o) {
20079 LDKAcceptChannel o_conv;
20080 o_conv.inner = untag_ptr(o);
20081 o_conv.is_owned = ptr_is_owned(o);
20082 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20083 o_conv = AcceptChannel_clone(&o_conv);
20084 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20085 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
20086 return tag_ptr(ret_conv, true);
20089 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_err"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint64_t e) {
20090 void* e_ptr = untag_ptr(e);
20091 CHECK_ACCESS(e_ptr);
20092 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20093 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20094 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20095 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
20096 return tag_ptr(ret_conv, true);
20099 jboolean __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_is_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint64_t o) {
20100 LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(o);
20101 jboolean ret_conv = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
20105 void __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_free"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint64_t _res) {
20106 if (!ptr_is_owned(_res)) return;
20107 void* _res_ptr = untag_ptr(_res);
20108 CHECK_ACCESS(_res_ptr);
20109 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(_res_ptr);
20110 FREE(untag_ptr(_res));
20111 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
20114 static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
20115 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20116 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
20117 return tag_ptr(ret_conv, true);
20119 int64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
20120 LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(arg);
20121 int64_t ret_conv = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
20125 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint64_t orig) {
20126 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(orig);
20127 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20128 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
20129 return tag_ptr(ret_conv, true);
20132 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint64_t o) {
20133 LDKAnnouncementSignatures o_conv;
20134 o_conv.inner = untag_ptr(o);
20135 o_conv.is_owned = ptr_is_owned(o);
20136 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20137 o_conv = AnnouncementSignatures_clone(&o_conv);
20138 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20139 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
20140 return tag_ptr(ret_conv, true);
20143 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint64_t e) {
20144 void* e_ptr = untag_ptr(e);
20145 CHECK_ACCESS(e_ptr);
20146 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20147 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20148 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20149 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
20150 return tag_ptr(ret_conv, true);
20153 jboolean __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint64_t o) {
20154 LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(o);
20155 jboolean ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
20159 void __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_free"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint64_t _res) {
20160 if (!ptr_is_owned(_res)) return;
20161 void* _res_ptr = untag_ptr(_res);
20162 CHECK_ACCESS(_res_ptr);
20163 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(_res_ptr);
20164 FREE(untag_ptr(_res));
20165 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
20168 static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
20169 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20170 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
20171 return tag_ptr(ret_conv, true);
20173 int64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
20174 LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(arg);
20175 int64_t ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
20179 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint64_t orig) {
20180 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(orig);
20181 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20182 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
20183 return tag_ptr(ret_conv, true);
20186 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint64_t o) {
20187 LDKChannelReestablish o_conv;
20188 o_conv.inner = untag_ptr(o);
20189 o_conv.is_owned = ptr_is_owned(o);
20190 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20191 o_conv = ChannelReestablish_clone(&o_conv);
20192 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20193 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
20194 return tag_ptr(ret_conv, true);
20197 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint64_t e) {
20198 void* e_ptr = untag_ptr(e);
20199 CHECK_ACCESS(e_ptr);
20200 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20201 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20202 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20203 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
20204 return tag_ptr(ret_conv, true);
20207 jboolean __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_is_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint64_t o) {
20208 LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(o);
20209 jboolean ret_conv = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
20213 void __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_free"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint64_t _res) {
20214 if (!ptr_is_owned(_res)) return;
20215 void* _res_ptr = untag_ptr(_res);
20216 CHECK_ACCESS(_res_ptr);
20217 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(_res_ptr);
20218 FREE(untag_ptr(_res));
20219 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
20222 static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
20223 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20224 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
20225 return tag_ptr(ret_conv, true);
20227 int64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint64_t arg) {
20228 LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(arg);
20229 int64_t ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
20233 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint64_t orig) {
20234 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(orig);
20235 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20236 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
20237 return tag_ptr(ret_conv, true);
20240 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint64_t o) {
20241 LDKClosingSigned o_conv;
20242 o_conv.inner = untag_ptr(o);
20243 o_conv.is_owned = ptr_is_owned(o);
20244 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20245 o_conv = ClosingSigned_clone(&o_conv);
20246 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20247 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
20248 return tag_ptr(ret_conv, true);
20251 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_err"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint64_t e) {
20252 void* e_ptr = untag_ptr(e);
20253 CHECK_ACCESS(e_ptr);
20254 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20255 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20256 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20257 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
20258 return tag_ptr(ret_conv, true);
20261 jboolean __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint64_t o) {
20262 LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(o);
20263 jboolean ret_conv = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
20267 void __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_free"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint64_t _res) {
20268 if (!ptr_is_owned(_res)) return;
20269 void* _res_ptr = untag_ptr(_res);
20270 CHECK_ACCESS(_res_ptr);
20271 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(_res_ptr);
20272 FREE(untag_ptr(_res));
20273 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
20276 static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
20277 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20278 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
20279 return tag_ptr(ret_conv, true);
20281 int64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
20282 LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(arg);
20283 int64_t ret_conv = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
20287 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint64_t orig) {
20288 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(orig);
20289 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20290 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
20291 return tag_ptr(ret_conv, true);
20294 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(uint64_t o) {
20295 LDKClosingSignedFeeRange o_conv;
20296 o_conv.inner = untag_ptr(o);
20297 o_conv.is_owned = ptr_is_owned(o);
20298 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20299 o_conv = ClosingSignedFeeRange_clone(&o_conv);
20300 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20301 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
20302 return tag_ptr(ret_conv, true);
20305 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(uint64_t e) {
20306 void* e_ptr = untag_ptr(e);
20307 CHECK_ACCESS(e_ptr);
20308 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20309 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20310 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20311 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
20312 return tag_ptr(ret_conv, true);
20315 jboolean __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint64_t o) {
20316 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(o);
20317 jboolean ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
20321 void __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint64_t _res) {
20322 if (!ptr_is_owned(_res)) return;
20323 void* _res_ptr = untag_ptr(_res);
20324 CHECK_ACCESS(_res_ptr);
20325 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(_res_ptr);
20326 FREE(untag_ptr(_res));
20327 CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
20330 static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
20331 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20332 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
20333 return tag_ptr(ret_conv, true);
20335 int64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
20336 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(arg);
20337 int64_t ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
20341 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint64_t orig) {
20342 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(orig);
20343 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20344 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig_conv);
20345 return tag_ptr(ret_conv, true);
20348 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint64_t o) {
20349 LDKCommitmentSigned o_conv;
20350 o_conv.inner = untag_ptr(o);
20351 o_conv.is_owned = ptr_is_owned(o);
20352 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20353 o_conv = CommitmentSigned_clone(&o_conv);
20354 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20355 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
20356 return tag_ptr(ret_conv, true);
20359 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint64_t e) {
20360 void* e_ptr = untag_ptr(e);
20361 CHECK_ACCESS(e_ptr);
20362 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20363 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20364 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20365 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
20366 return tag_ptr(ret_conv, true);
20369 jboolean __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_is_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint64_t o) {
20370 LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(o);
20371 jboolean ret_conv = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
20375 void __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_free"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint64_t _res) {
20376 if (!ptr_is_owned(_res)) return;
20377 void* _res_ptr = untag_ptr(_res);
20378 CHECK_ACCESS(_res_ptr);
20379 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(_res_ptr);
20380 FREE(untag_ptr(_res));
20381 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
20384 static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
20385 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20386 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
20387 return tag_ptr(ret_conv, true);
20389 int64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
20390 LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(arg);
20391 int64_t ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
20395 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint64_t orig) {
20396 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(orig);
20397 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20398 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
20399 return tag_ptr(ret_conv, true);
20402 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint64_t o) {
20403 LDKFundingCreated o_conv;
20404 o_conv.inner = untag_ptr(o);
20405 o_conv.is_owned = ptr_is_owned(o);
20406 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20407 o_conv = FundingCreated_clone(&o_conv);
20408 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20409 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
20410 return tag_ptr(ret_conv, true);
20413 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_err"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint64_t e) {
20414 void* e_ptr = untag_ptr(e);
20415 CHECK_ACCESS(e_ptr);
20416 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20417 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20418 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20419 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
20420 return tag_ptr(ret_conv, true);
20423 jboolean __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_is_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint64_t o) {
20424 LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(o);
20425 jboolean ret_conv = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
20429 void __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_free"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint64_t _res) {
20430 if (!ptr_is_owned(_res)) return;
20431 void* _res_ptr = untag_ptr(_res);
20432 CHECK_ACCESS(_res_ptr);
20433 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(_res_ptr);
20434 FREE(untag_ptr(_res));
20435 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
20438 static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
20439 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20440 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
20441 return tag_ptr(ret_conv, true);
20443 int64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint64_t arg) {
20444 LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(arg);
20445 int64_t ret_conv = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
20449 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint64_t orig) {
20450 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(orig);
20451 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20452 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
20453 return tag_ptr(ret_conv, true);
20456 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_ok"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint64_t o) {
20457 LDKFundingSigned o_conv;
20458 o_conv.inner = untag_ptr(o);
20459 o_conv.is_owned = ptr_is_owned(o);
20460 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20461 o_conv = FundingSigned_clone(&o_conv);
20462 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20463 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
20464 return tag_ptr(ret_conv, true);
20467 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_err"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint64_t e) {
20468 void* e_ptr = untag_ptr(e);
20469 CHECK_ACCESS(e_ptr);
20470 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20471 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20472 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20473 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
20474 return tag_ptr(ret_conv, true);
20477 jboolean __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_is_ok"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint64_t o) {
20478 LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(o);
20479 jboolean ret_conv = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
20483 void __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_free"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint64_t _res) {
20484 if (!ptr_is_owned(_res)) return;
20485 void* _res_ptr = untag_ptr(_res);
20486 CHECK_ACCESS(_res_ptr);
20487 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(_res_ptr);
20488 FREE(untag_ptr(_res));
20489 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
20492 static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
20493 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20494 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
20495 return tag_ptr(ret_conv, true);
20497 int64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
20498 LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(arg);
20499 int64_t ret_conv = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
20503 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint64_t orig) {
20504 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(orig);
20505 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20506 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
20507 return tag_ptr(ret_conv, true);
20510 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_ok(uint64_t o) {
20511 LDKChannelReady o_conv;
20512 o_conv.inner = untag_ptr(o);
20513 o_conv.is_owned = ptr_is_owned(o);
20514 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20515 o_conv = ChannelReady_clone(&o_conv);
20516 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20517 *ret_conv = CResult_ChannelReadyDecodeErrorZ_ok(o_conv);
20518 return tag_ptr(ret_conv, true);
20521 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_err"))) TS_CResult_ChannelReadyDecodeErrorZ_err(uint64_t e) {
20522 void* e_ptr = untag_ptr(e);
20523 CHECK_ACCESS(e_ptr);
20524 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20525 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20526 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20527 *ret_conv = CResult_ChannelReadyDecodeErrorZ_err(e_conv);
20528 return tag_ptr(ret_conv, true);
20531 jboolean __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_is_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_is_ok(uint64_t o) {
20532 LDKCResult_ChannelReadyDecodeErrorZ* o_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(o);
20533 jboolean ret_conv = CResult_ChannelReadyDecodeErrorZ_is_ok(o_conv);
20537 void __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_free"))) TS_CResult_ChannelReadyDecodeErrorZ_free(uint64_t _res) {
20538 if (!ptr_is_owned(_res)) return;
20539 void* _res_ptr = untag_ptr(_res);
20540 CHECK_ACCESS(_res_ptr);
20541 LDKCResult_ChannelReadyDecodeErrorZ _res_conv = *(LDKCResult_ChannelReadyDecodeErrorZ*)(_res_ptr);
20542 FREE(untag_ptr(_res));
20543 CResult_ChannelReadyDecodeErrorZ_free(_res_conv);
20546 static inline uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg) {
20547 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20548 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(arg);
20549 return tag_ptr(ret_conv, true);
20551 int64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(uint64_t arg) {
20552 LDKCResult_ChannelReadyDecodeErrorZ* arg_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(arg);
20553 int64_t ret_conv = CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg_conv);
20557 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone"))) TS_CResult_ChannelReadyDecodeErrorZ_clone(uint64_t orig) {
20558 LDKCResult_ChannelReadyDecodeErrorZ* orig_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(orig);
20559 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20560 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(orig_conv);
20561 return tag_ptr(ret_conv, true);
20564 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_ok"))) TS_CResult_InitDecodeErrorZ_ok(uint64_t o) {
20566 o_conv.inner = untag_ptr(o);
20567 o_conv.is_owned = ptr_is_owned(o);
20568 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20569 o_conv = Init_clone(&o_conv);
20570 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20571 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
20572 return tag_ptr(ret_conv, true);
20575 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_err"))) TS_CResult_InitDecodeErrorZ_err(uint64_t e) {
20576 void* e_ptr = untag_ptr(e);
20577 CHECK_ACCESS(e_ptr);
20578 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20579 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20580 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20581 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
20582 return tag_ptr(ret_conv, true);
20585 jboolean __attribute__((export_name("TS_CResult_InitDecodeErrorZ_is_ok"))) TS_CResult_InitDecodeErrorZ_is_ok(uint64_t o) {
20586 LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(o);
20587 jboolean ret_conv = CResult_InitDecodeErrorZ_is_ok(o_conv);
20591 void __attribute__((export_name("TS_CResult_InitDecodeErrorZ_free"))) TS_CResult_InitDecodeErrorZ_free(uint64_t _res) {
20592 if (!ptr_is_owned(_res)) return;
20593 void* _res_ptr = untag_ptr(_res);
20594 CHECK_ACCESS(_res_ptr);
20595 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(_res_ptr);
20596 FREE(untag_ptr(_res));
20597 CResult_InitDecodeErrorZ_free(_res_conv);
20600 static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
20601 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20602 *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
20603 return tag_ptr(ret_conv, true);
20605 int64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone_ptr"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint64_t arg) {
20606 LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(arg);
20607 int64_t ret_conv = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
20611 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone"))) TS_CResult_InitDecodeErrorZ_clone(uint64_t orig) {
20612 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(orig);
20613 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20614 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
20615 return tag_ptr(ret_conv, true);
20618 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_ok"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint64_t o) {
20619 LDKOpenChannel o_conv;
20620 o_conv.inner = untag_ptr(o);
20621 o_conv.is_owned = ptr_is_owned(o);
20622 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20623 o_conv = OpenChannel_clone(&o_conv);
20624 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20625 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
20626 return tag_ptr(ret_conv, true);
20629 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_err"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint64_t e) {
20630 void* e_ptr = untag_ptr(e);
20631 CHECK_ACCESS(e_ptr);
20632 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20633 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20634 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20635 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
20636 return tag_ptr(ret_conv, true);
20639 jboolean __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_is_ok"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint64_t o) {
20640 LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(o);
20641 jboolean ret_conv = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
20645 void __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_free"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint64_t _res) {
20646 if (!ptr_is_owned(_res)) return;
20647 void* _res_ptr = untag_ptr(_res);
20648 CHECK_ACCESS(_res_ptr);
20649 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(_res_ptr);
20650 FREE(untag_ptr(_res));
20651 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
20654 static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
20655 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20656 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
20657 return tag_ptr(ret_conv, true);
20659 int64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone_ptr"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
20660 LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(arg);
20661 int64_t ret_conv = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
20665 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint64_t orig) {
20666 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(orig);
20667 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20668 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
20669 return tag_ptr(ret_conv, true);
20672 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint64_t o) {
20673 LDKRevokeAndACK o_conv;
20674 o_conv.inner = untag_ptr(o);
20675 o_conv.is_owned = ptr_is_owned(o);
20676 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20677 o_conv = RevokeAndACK_clone(&o_conv);
20678 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20679 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
20680 return tag_ptr(ret_conv, true);
20683 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint64_t e) {
20684 void* e_ptr = untag_ptr(e);
20685 CHECK_ACCESS(e_ptr);
20686 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20687 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20688 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20689 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
20690 return tag_ptr(ret_conv, true);
20693 jboolean __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_is_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint64_t o) {
20694 LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(o);
20695 jboolean ret_conv = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
20699 void __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_free"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint64_t _res) {
20700 if (!ptr_is_owned(_res)) return;
20701 void* _res_ptr = untag_ptr(_res);
20702 CHECK_ACCESS(_res_ptr);
20703 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(_res_ptr);
20704 FREE(untag_ptr(_res));
20705 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
20708 static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
20709 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20710 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
20711 return tag_ptr(ret_conv, true);
20713 int64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint64_t arg) {
20714 LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(arg);
20715 int64_t ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
20719 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint64_t orig) {
20720 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(orig);
20721 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20722 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
20723 return tag_ptr(ret_conv, true);
20726 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_ok"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint64_t o) {
20727 LDKShutdown o_conv;
20728 o_conv.inner = untag_ptr(o);
20729 o_conv.is_owned = ptr_is_owned(o);
20730 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20731 o_conv = Shutdown_clone(&o_conv);
20732 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20733 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
20734 return tag_ptr(ret_conv, true);
20737 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_err"))) TS_CResult_ShutdownDecodeErrorZ_err(uint64_t e) {
20738 void* e_ptr = untag_ptr(e);
20739 CHECK_ACCESS(e_ptr);
20740 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20741 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20742 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20743 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
20744 return tag_ptr(ret_conv, true);
20747 jboolean __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_is_ok"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint64_t o) {
20748 LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(o);
20749 jboolean ret_conv = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
20753 void __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_free"))) TS_CResult_ShutdownDecodeErrorZ_free(uint64_t _res) {
20754 if (!ptr_is_owned(_res)) return;
20755 void* _res_ptr = untag_ptr(_res);
20756 CHECK_ACCESS(_res_ptr);
20757 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(_res_ptr);
20758 FREE(untag_ptr(_res));
20759 CResult_ShutdownDecodeErrorZ_free(_res_conv);
20762 static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
20763 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20764 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
20765 return tag_ptr(ret_conv, true);
20767 int64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint64_t arg) {
20768 LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(arg);
20769 int64_t ret_conv = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
20773 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint64_t orig) {
20774 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(orig);
20775 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20776 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
20777 return tag_ptr(ret_conv, true);
20780 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint64_t o) {
20781 LDKUpdateFailHTLC o_conv;
20782 o_conv.inner = untag_ptr(o);
20783 o_conv.is_owned = ptr_is_owned(o);
20784 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20785 o_conv = UpdateFailHTLC_clone(&o_conv);
20786 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20787 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
20788 return tag_ptr(ret_conv, true);
20791 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint64_t e) {
20792 void* e_ptr = untag_ptr(e);
20793 CHECK_ACCESS(e_ptr);
20794 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20795 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20796 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20797 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
20798 return tag_ptr(ret_conv, true);
20801 jboolean __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint64_t o) {
20802 LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(o);
20803 jboolean ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
20807 void __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint64_t _res) {
20808 if (!ptr_is_owned(_res)) return;
20809 void* _res_ptr = untag_ptr(_res);
20810 CHECK_ACCESS(_res_ptr);
20811 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(_res_ptr);
20812 FREE(untag_ptr(_res));
20813 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
20816 static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
20817 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20818 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
20819 return tag_ptr(ret_conv, true);
20821 int64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20822 LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(arg);
20823 int64_t ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
20827 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint64_t orig) {
20828 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(orig);
20829 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20830 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
20831 return tag_ptr(ret_conv, true);
20834 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint64_t o) {
20835 LDKUpdateFailMalformedHTLC o_conv;
20836 o_conv.inner = untag_ptr(o);
20837 o_conv.is_owned = ptr_is_owned(o);
20838 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20839 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
20840 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20841 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
20842 return tag_ptr(ret_conv, true);
20845 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint64_t e) {
20846 void* e_ptr = untag_ptr(e);
20847 CHECK_ACCESS(e_ptr);
20848 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20849 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20850 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20851 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
20852 return tag_ptr(ret_conv, true);
20855 jboolean __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint64_t o) {
20856 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(o);
20857 jboolean ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
20861 void __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint64_t _res) {
20862 if (!ptr_is_owned(_res)) return;
20863 void* _res_ptr = untag_ptr(_res);
20864 CHECK_ACCESS(_res_ptr);
20865 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(_res_ptr);
20866 FREE(untag_ptr(_res));
20867 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
20870 static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
20871 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20872 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
20873 return tag_ptr(ret_conv, true);
20875 int64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20876 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(arg);
20877 int64_t ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
20881 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint64_t orig) {
20882 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(orig);
20883 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20884 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
20885 return tag_ptr(ret_conv, true);
20888 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint64_t o) {
20889 LDKUpdateFee o_conv;
20890 o_conv.inner = untag_ptr(o);
20891 o_conv.is_owned = ptr_is_owned(o);
20892 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20893 o_conv = UpdateFee_clone(&o_conv);
20894 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20895 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
20896 return tag_ptr(ret_conv, true);
20899 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_err"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint64_t e) {
20900 void* e_ptr = untag_ptr(e);
20901 CHECK_ACCESS(e_ptr);
20902 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20903 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20904 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20905 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
20906 return tag_ptr(ret_conv, true);
20909 jboolean __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_is_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint64_t o) {
20910 LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(o);
20911 jboolean ret_conv = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
20915 void __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_free"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint64_t _res) {
20916 if (!ptr_is_owned(_res)) return;
20917 void* _res_ptr = untag_ptr(_res);
20918 CHECK_ACCESS(_res_ptr);
20919 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(_res_ptr);
20920 FREE(untag_ptr(_res));
20921 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
20924 static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
20925 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20926 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
20927 return tag_ptr(ret_conv, true);
20929 int64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint64_t arg) {
20930 LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(arg);
20931 int64_t ret_conv = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
20935 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint64_t orig) {
20936 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(orig);
20937 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20938 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
20939 return tag_ptr(ret_conv, true);
20942 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint64_t o) {
20943 LDKUpdateFulfillHTLC o_conv;
20944 o_conv.inner = untag_ptr(o);
20945 o_conv.is_owned = ptr_is_owned(o);
20946 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20947 o_conv = UpdateFulfillHTLC_clone(&o_conv);
20948 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20949 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
20950 return tag_ptr(ret_conv, true);
20953 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint64_t e) {
20954 void* e_ptr = untag_ptr(e);
20955 CHECK_ACCESS(e_ptr);
20956 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20957 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20958 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20959 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
20960 return tag_ptr(ret_conv, true);
20963 jboolean __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint64_t o) {
20964 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(o);
20965 jboolean ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
20969 void __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint64_t _res) {
20970 if (!ptr_is_owned(_res)) return;
20971 void* _res_ptr = untag_ptr(_res);
20972 CHECK_ACCESS(_res_ptr);
20973 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(_res_ptr);
20974 FREE(untag_ptr(_res));
20975 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
20978 static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
20979 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20980 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
20981 return tag_ptr(ret_conv, true);
20983 int64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20984 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(arg);
20985 int64_t ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
20989 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint64_t orig) {
20990 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(orig);
20991 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20992 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
20993 return tag_ptr(ret_conv, true);
20996 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint64_t o) {
20997 LDKUpdateAddHTLC o_conv;
20998 o_conv.inner = untag_ptr(o);
20999 o_conv.is_owned = ptr_is_owned(o);
21000 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21001 o_conv = UpdateAddHTLC_clone(&o_conv);
21002 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21003 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
21004 return tag_ptr(ret_conv, true);
21007 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint64_t e) {
21008 void* e_ptr = untag_ptr(e);
21009 CHECK_ACCESS(e_ptr);
21010 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21011 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21012 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21013 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
21014 return tag_ptr(ret_conv, true);
21017 jboolean __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint64_t o) {
21018 LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(o);
21019 jboolean ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
21023 void __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_free"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint64_t _res) {
21024 if (!ptr_is_owned(_res)) return;
21025 void* _res_ptr = untag_ptr(_res);
21026 CHECK_ACCESS(_res_ptr);
21027 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(_res_ptr);
21028 FREE(untag_ptr(_res));
21029 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
21032 static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
21033 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21034 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
21035 return tag_ptr(ret_conv, true);
21037 int64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
21038 LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(arg);
21039 int64_t ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
21043 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint64_t orig) {
21044 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(orig);
21045 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21046 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
21047 return tag_ptr(ret_conv, true);
21050 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_ok"))) TS_CResult_OnionMessageDecodeErrorZ_ok(uint64_t o) {
21051 LDKOnionMessage o_conv;
21052 o_conv.inner = untag_ptr(o);
21053 o_conv.is_owned = ptr_is_owned(o);
21054 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21055 o_conv = OnionMessage_clone(&o_conv);
21056 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21057 *ret_conv = CResult_OnionMessageDecodeErrorZ_ok(o_conv);
21058 return tag_ptr(ret_conv, true);
21061 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_err"))) TS_CResult_OnionMessageDecodeErrorZ_err(uint64_t e) {
21062 void* e_ptr = untag_ptr(e);
21063 CHECK_ACCESS(e_ptr);
21064 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21065 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21066 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21067 *ret_conv = CResult_OnionMessageDecodeErrorZ_err(e_conv);
21068 return tag_ptr(ret_conv, true);
21071 jboolean __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_is_ok"))) TS_CResult_OnionMessageDecodeErrorZ_is_ok(uint64_t o) {
21072 LDKCResult_OnionMessageDecodeErrorZ* o_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(o);
21073 jboolean ret_conv = CResult_OnionMessageDecodeErrorZ_is_ok(o_conv);
21077 void __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_free"))) TS_CResult_OnionMessageDecodeErrorZ_free(uint64_t _res) {
21078 if (!ptr_is_owned(_res)) return;
21079 void* _res_ptr = untag_ptr(_res);
21080 CHECK_ACCESS(_res_ptr);
21081 LDKCResult_OnionMessageDecodeErrorZ _res_conv = *(LDKCResult_OnionMessageDecodeErrorZ*)(_res_ptr);
21082 FREE(untag_ptr(_res));
21083 CResult_OnionMessageDecodeErrorZ_free(_res_conv);
21086 static inline uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg) {
21087 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21088 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(arg);
21089 return tag_ptr(ret_conv, true);
21091 int64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone_ptr"))) TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
21092 LDKCResult_OnionMessageDecodeErrorZ* arg_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(arg);
21093 int64_t ret_conv = CResult_OnionMessageDecodeErrorZ_clone_ptr(arg_conv);
21097 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone"))) TS_CResult_OnionMessageDecodeErrorZ_clone(uint64_t orig) {
21098 LDKCResult_OnionMessageDecodeErrorZ* orig_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(orig);
21099 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21100 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(orig_conv);
21101 return tag_ptr(ret_conv, true);
21104 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_ok"))) TS_CResult_PingDecodeErrorZ_ok(uint64_t o) {
21106 o_conv.inner = untag_ptr(o);
21107 o_conv.is_owned = ptr_is_owned(o);
21108 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21109 o_conv = Ping_clone(&o_conv);
21110 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21111 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
21112 return tag_ptr(ret_conv, true);
21115 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_err"))) TS_CResult_PingDecodeErrorZ_err(uint64_t e) {
21116 void* e_ptr = untag_ptr(e);
21117 CHECK_ACCESS(e_ptr);
21118 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21119 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21120 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21121 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
21122 return tag_ptr(ret_conv, true);
21125 jboolean __attribute__((export_name("TS_CResult_PingDecodeErrorZ_is_ok"))) TS_CResult_PingDecodeErrorZ_is_ok(uint64_t o) {
21126 LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(o);
21127 jboolean ret_conv = CResult_PingDecodeErrorZ_is_ok(o_conv);
21131 void __attribute__((export_name("TS_CResult_PingDecodeErrorZ_free"))) TS_CResult_PingDecodeErrorZ_free(uint64_t _res) {
21132 if (!ptr_is_owned(_res)) return;
21133 void* _res_ptr = untag_ptr(_res);
21134 CHECK_ACCESS(_res_ptr);
21135 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(_res_ptr);
21136 FREE(untag_ptr(_res));
21137 CResult_PingDecodeErrorZ_free(_res_conv);
21140 static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
21141 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21142 *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
21143 return tag_ptr(ret_conv, true);
21145 int64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone_ptr"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint64_t arg) {
21146 LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(arg);
21147 int64_t ret_conv = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
21151 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone"))) TS_CResult_PingDecodeErrorZ_clone(uint64_t orig) {
21152 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(orig);
21153 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21154 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
21155 return tag_ptr(ret_conv, true);
21158 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_ok"))) TS_CResult_PongDecodeErrorZ_ok(uint64_t o) {
21160 o_conv.inner = untag_ptr(o);
21161 o_conv.is_owned = ptr_is_owned(o);
21162 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21163 o_conv = Pong_clone(&o_conv);
21164 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21165 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
21166 return tag_ptr(ret_conv, true);
21169 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_err"))) TS_CResult_PongDecodeErrorZ_err(uint64_t e) {
21170 void* e_ptr = untag_ptr(e);
21171 CHECK_ACCESS(e_ptr);
21172 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21173 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21174 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21175 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
21176 return tag_ptr(ret_conv, true);
21179 jboolean __attribute__((export_name("TS_CResult_PongDecodeErrorZ_is_ok"))) TS_CResult_PongDecodeErrorZ_is_ok(uint64_t o) {
21180 LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(o);
21181 jboolean ret_conv = CResult_PongDecodeErrorZ_is_ok(o_conv);
21185 void __attribute__((export_name("TS_CResult_PongDecodeErrorZ_free"))) TS_CResult_PongDecodeErrorZ_free(uint64_t _res) {
21186 if (!ptr_is_owned(_res)) return;
21187 void* _res_ptr = untag_ptr(_res);
21188 CHECK_ACCESS(_res_ptr);
21189 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(_res_ptr);
21190 FREE(untag_ptr(_res));
21191 CResult_PongDecodeErrorZ_free(_res_conv);
21194 static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
21195 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21196 *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
21197 return tag_ptr(ret_conv, true);
21199 int64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone_ptr"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint64_t arg) {
21200 LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(arg);
21201 int64_t ret_conv = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
21205 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone"))) TS_CResult_PongDecodeErrorZ_clone(uint64_t orig) {
21206 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(orig);
21207 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21208 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
21209 return tag_ptr(ret_conv, true);
21212 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
21213 LDKUnsignedChannelAnnouncement o_conv;
21214 o_conv.inner = untag_ptr(o);
21215 o_conv.is_owned = ptr_is_owned(o);
21216 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21217 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
21218 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21219 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
21220 return tag_ptr(ret_conv, true);
21223 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
21224 void* e_ptr = untag_ptr(e);
21225 CHECK_ACCESS(e_ptr);
21226 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21227 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21228 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21229 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
21230 return tag_ptr(ret_conv, true);
21233 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21234 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
21235 jboolean ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
21239 void __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
21240 if (!ptr_is_owned(_res)) return;
21241 void* _res_ptr = untag_ptr(_res);
21242 CHECK_ACCESS(_res_ptr);
21243 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(_res_ptr);
21244 FREE(untag_ptr(_res));
21245 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
21248 static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21249 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21250 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
21251 return tag_ptr(ret_conv, true);
21253 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21254 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
21255 int64_t ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21259 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21260 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
21261 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21262 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
21263 return tag_ptr(ret_conv, true);
21266 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
21267 LDKChannelAnnouncement o_conv;
21268 o_conv.inner = untag_ptr(o);
21269 o_conv.is_owned = ptr_is_owned(o);
21270 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21271 o_conv = ChannelAnnouncement_clone(&o_conv);
21272 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21273 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
21274 return tag_ptr(ret_conv, true);
21277 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
21278 void* e_ptr = untag_ptr(e);
21279 CHECK_ACCESS(e_ptr);
21280 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21281 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21282 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21283 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
21284 return tag_ptr(ret_conv, true);
21287 jboolean __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21288 LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
21289 jboolean ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
21293 void __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
21294 if (!ptr_is_owned(_res)) return;
21295 void* _res_ptr = untag_ptr(_res);
21296 CHECK_ACCESS(_res_ptr);
21297 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(_res_ptr);
21298 FREE(untag_ptr(_res));
21299 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
21302 static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21303 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21304 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
21305 return tag_ptr(ret_conv, true);
21307 int64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21308 LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
21309 int64_t ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21313 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21314 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
21315 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21316 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
21317 return tag_ptr(ret_conv, true);
21320 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint64_t o) {
21321 LDKUnsignedChannelUpdate o_conv;
21322 o_conv.inner = untag_ptr(o);
21323 o_conv.is_owned = ptr_is_owned(o);
21324 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21325 o_conv = UnsignedChannelUpdate_clone(&o_conv);
21326 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21327 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
21328 return tag_ptr(ret_conv, true);
21331 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint64_t e) {
21332 void* e_ptr = untag_ptr(e);
21333 CHECK_ACCESS(e_ptr);
21334 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21335 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21336 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21337 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
21338 return tag_ptr(ret_conv, true);
21341 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
21342 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(o);
21343 jboolean ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
21347 void __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint64_t _res) {
21348 if (!ptr_is_owned(_res)) return;
21349 void* _res_ptr = untag_ptr(_res);
21350 CHECK_ACCESS(_res_ptr);
21351 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(_res_ptr);
21352 FREE(untag_ptr(_res));
21353 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
21356 static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
21357 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21358 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
21359 return tag_ptr(ret_conv, true);
21361 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
21362 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(arg);
21363 int64_t ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
21367 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
21368 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(orig);
21369 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21370 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
21371 return tag_ptr(ret_conv, true);
21374 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint64_t o) {
21375 LDKChannelUpdate o_conv;
21376 o_conv.inner = untag_ptr(o);
21377 o_conv.is_owned = ptr_is_owned(o);
21378 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21379 o_conv = ChannelUpdate_clone(&o_conv);
21380 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21381 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
21382 return tag_ptr(ret_conv, true);
21385 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint64_t e) {
21386 void* e_ptr = untag_ptr(e);
21387 CHECK_ACCESS(e_ptr);
21388 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21389 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21390 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21391 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
21392 return tag_ptr(ret_conv, true);
21395 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
21396 LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(o);
21397 jboolean ret_conv = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
21401 void __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_free"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint64_t _res) {
21402 if (!ptr_is_owned(_res)) return;
21403 void* _res_ptr = untag_ptr(_res);
21404 CHECK_ACCESS(_res_ptr);
21405 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(_res_ptr);
21406 FREE(untag_ptr(_res));
21407 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
21410 static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
21411 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21412 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
21413 return tag_ptr(ret_conv, true);
21415 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
21416 LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(arg);
21417 int64_t ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
21421 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
21422 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(orig);
21423 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21424 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
21425 return tag_ptr(ret_conv, true);
21428 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint64_t o) {
21429 LDKErrorMessage o_conv;
21430 o_conv.inner = untag_ptr(o);
21431 o_conv.is_owned = ptr_is_owned(o);
21432 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21433 o_conv = ErrorMessage_clone(&o_conv);
21434 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21435 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
21436 return tag_ptr(ret_conv, true);
21439 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_err"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint64_t e) {
21440 void* e_ptr = untag_ptr(e);
21441 CHECK_ACCESS(e_ptr);
21442 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21443 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21444 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21445 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
21446 return tag_ptr(ret_conv, true);
21449 jboolean __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_is_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint64_t o) {
21450 LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(o);
21451 jboolean ret_conv = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
21455 void __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_free"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint64_t _res) {
21456 if (!ptr_is_owned(_res)) return;
21457 void* _res_ptr = untag_ptr(_res);
21458 CHECK_ACCESS(_res_ptr);
21459 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(_res_ptr);
21460 FREE(untag_ptr(_res));
21461 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
21464 static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
21465 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21466 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
21467 return tag_ptr(ret_conv, true);
21469 int64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
21470 LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(arg);
21471 int64_t ret_conv = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
21475 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint64_t orig) {
21476 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(orig);
21477 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21478 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
21479 return tag_ptr(ret_conv, true);
21482 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_ok"))) TS_CResult_WarningMessageDecodeErrorZ_ok(uint64_t o) {
21483 LDKWarningMessage o_conv;
21484 o_conv.inner = untag_ptr(o);
21485 o_conv.is_owned = ptr_is_owned(o);
21486 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21487 o_conv = WarningMessage_clone(&o_conv);
21488 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21489 *ret_conv = CResult_WarningMessageDecodeErrorZ_ok(o_conv);
21490 return tag_ptr(ret_conv, true);
21493 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_err"))) TS_CResult_WarningMessageDecodeErrorZ_err(uint64_t e) {
21494 void* e_ptr = untag_ptr(e);
21495 CHECK_ACCESS(e_ptr);
21496 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21497 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21498 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21499 *ret_conv = CResult_WarningMessageDecodeErrorZ_err(e_conv);
21500 return tag_ptr(ret_conv, true);
21503 jboolean __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_is_ok"))) TS_CResult_WarningMessageDecodeErrorZ_is_ok(uint64_t o) {
21504 LDKCResult_WarningMessageDecodeErrorZ* o_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(o);
21505 jboolean ret_conv = CResult_WarningMessageDecodeErrorZ_is_ok(o_conv);
21509 void __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_free"))) TS_CResult_WarningMessageDecodeErrorZ_free(uint64_t _res) {
21510 if (!ptr_is_owned(_res)) return;
21511 void* _res_ptr = untag_ptr(_res);
21512 CHECK_ACCESS(_res_ptr);
21513 LDKCResult_WarningMessageDecodeErrorZ _res_conv = *(LDKCResult_WarningMessageDecodeErrorZ*)(_res_ptr);
21514 FREE(untag_ptr(_res));
21515 CResult_WarningMessageDecodeErrorZ_free(_res_conv);
21518 static inline uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg) {
21519 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21520 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(arg);
21521 return tag_ptr(ret_conv, true);
21523 int64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone_ptr"))) TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
21524 LDKCResult_WarningMessageDecodeErrorZ* arg_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(arg);
21525 int64_t ret_conv = CResult_WarningMessageDecodeErrorZ_clone_ptr(arg_conv);
21529 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone"))) TS_CResult_WarningMessageDecodeErrorZ_clone(uint64_t orig) {
21530 LDKCResult_WarningMessageDecodeErrorZ* orig_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(orig);
21531 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21532 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(orig_conv);
21533 return tag_ptr(ret_conv, true);
21536 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
21537 LDKUnsignedNodeAnnouncement o_conv;
21538 o_conv.inner = untag_ptr(o);
21539 o_conv.is_owned = ptr_is_owned(o);
21540 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21541 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
21542 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21543 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
21544 return tag_ptr(ret_conv, true);
21547 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint64_t e) {
21548 void* e_ptr = untag_ptr(e);
21549 CHECK_ACCESS(e_ptr);
21550 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21551 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21552 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21553 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
21554 return tag_ptr(ret_conv, true);
21557 jboolean __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21558 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(o);
21559 jboolean ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
21563 void __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
21564 if (!ptr_is_owned(_res)) return;
21565 void* _res_ptr = untag_ptr(_res);
21566 CHECK_ACCESS(_res_ptr);
21567 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(_res_ptr);
21568 FREE(untag_ptr(_res));
21569 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
21572 static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21573 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21574 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
21575 return tag_ptr(ret_conv, true);
21577 int64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21578 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
21579 int64_t ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21583 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21584 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
21585 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21586 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
21587 return tag_ptr(ret_conv, true);
21590 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
21591 LDKNodeAnnouncement o_conv;
21592 o_conv.inner = untag_ptr(o);
21593 o_conv.is_owned = ptr_is_owned(o);
21594 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21595 o_conv = NodeAnnouncement_clone(&o_conv);
21596 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21597 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
21598 return tag_ptr(ret_conv, true);
21601 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint64_t e) {
21602 void* e_ptr = untag_ptr(e);
21603 CHECK_ACCESS(e_ptr);
21604 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21605 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21606 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21607 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
21608 return tag_ptr(ret_conv, true);
21611 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21612 LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(o);
21613 jboolean ret_conv = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
21617 void __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
21618 if (!ptr_is_owned(_res)) return;
21619 void* _res_ptr = untag_ptr(_res);
21620 CHECK_ACCESS(_res_ptr);
21621 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(_res_ptr);
21622 FREE(untag_ptr(_res));
21623 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
21626 static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21627 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21628 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
21629 return tag_ptr(ret_conv, true);
21631 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21632 LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
21633 int64_t ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21637 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21638 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
21639 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21640 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
21641 return tag_ptr(ret_conv, true);
21644 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint64_t o) {
21645 LDKQueryShortChannelIds o_conv;
21646 o_conv.inner = untag_ptr(o);
21647 o_conv.is_owned = ptr_is_owned(o);
21648 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21649 o_conv = QueryShortChannelIds_clone(&o_conv);
21650 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21651 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
21652 return tag_ptr(ret_conv, true);
21655 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint64_t e) {
21656 void* e_ptr = untag_ptr(e);
21657 CHECK_ACCESS(e_ptr);
21658 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21659 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21660 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21661 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
21662 return tag_ptr(ret_conv, true);
21665 jboolean __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint64_t o) {
21666 LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(o);
21667 jboolean ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
21671 void __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_free"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint64_t _res) {
21672 if (!ptr_is_owned(_res)) return;
21673 void* _res_ptr = untag_ptr(_res);
21674 CHECK_ACCESS(_res_ptr);
21675 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(_res_ptr);
21676 FREE(untag_ptr(_res));
21677 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
21680 static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
21681 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21682 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
21683 return tag_ptr(ret_conv, true);
21685 int64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint64_t arg) {
21686 LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(arg);
21687 int64_t ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
21691 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint64_t orig) {
21692 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(orig);
21693 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21694 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
21695 return tag_ptr(ret_conv, true);
21698 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint64_t o) {
21699 LDKReplyShortChannelIdsEnd o_conv;
21700 o_conv.inner = untag_ptr(o);
21701 o_conv.is_owned = ptr_is_owned(o);
21702 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21703 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
21704 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21705 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
21706 return tag_ptr(ret_conv, true);
21709 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint64_t e) {
21710 void* e_ptr = untag_ptr(e);
21711 CHECK_ACCESS(e_ptr);
21712 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21713 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21714 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21715 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
21716 return tag_ptr(ret_conv, true);
21719 jboolean __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint64_t o) {
21720 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(o);
21721 jboolean ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
21725 void __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint64_t _res) {
21726 if (!ptr_is_owned(_res)) return;
21727 void* _res_ptr = untag_ptr(_res);
21728 CHECK_ACCESS(_res_ptr);
21729 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(_res_ptr);
21730 FREE(untag_ptr(_res));
21731 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
21734 static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
21735 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21736 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
21737 return tag_ptr(ret_conv, true);
21739 int64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint64_t arg) {
21740 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(arg);
21741 int64_t ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
21745 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint64_t orig) {
21746 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(orig);
21747 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21748 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
21749 return tag_ptr(ret_conv, true);
21752 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint64_t o) {
21753 LDKQueryChannelRange o_conv;
21754 o_conv.inner = untag_ptr(o);
21755 o_conv.is_owned = ptr_is_owned(o);
21756 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21757 o_conv = QueryChannelRange_clone(&o_conv);
21758 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21759 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
21760 return tag_ptr(ret_conv, true);
21763 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint64_t e) {
21764 void* e_ptr = untag_ptr(e);
21765 CHECK_ACCESS(e_ptr);
21766 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21767 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21768 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21769 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
21770 return tag_ptr(ret_conv, true);
21773 jboolean __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
21774 LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(o);
21775 jboolean ret_conv = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
21779 void __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_free"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint64_t _res) {
21780 if (!ptr_is_owned(_res)) return;
21781 void* _res_ptr = untag_ptr(_res);
21782 CHECK_ACCESS(_res_ptr);
21783 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(_res_ptr);
21784 FREE(untag_ptr(_res));
21785 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
21788 static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
21789 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21790 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
21791 return tag_ptr(ret_conv, true);
21793 int64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
21794 LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(arg);
21795 int64_t ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
21799 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint64_t orig) {
21800 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(orig);
21801 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21802 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
21803 return tag_ptr(ret_conv, true);
21806 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint64_t o) {
21807 LDKReplyChannelRange o_conv;
21808 o_conv.inner = untag_ptr(o);
21809 o_conv.is_owned = ptr_is_owned(o);
21810 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21811 o_conv = ReplyChannelRange_clone(&o_conv);
21812 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21813 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
21814 return tag_ptr(ret_conv, true);
21817 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint64_t e) {
21818 void* e_ptr = untag_ptr(e);
21819 CHECK_ACCESS(e_ptr);
21820 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21821 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21822 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21823 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
21824 return tag_ptr(ret_conv, true);
21827 jboolean __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
21828 LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(o);
21829 jboolean ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
21833 void __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_free"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint64_t _res) {
21834 if (!ptr_is_owned(_res)) return;
21835 void* _res_ptr = untag_ptr(_res);
21836 CHECK_ACCESS(_res_ptr);
21837 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(_res_ptr);
21838 FREE(untag_ptr(_res));
21839 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
21842 static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
21843 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21844 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
21845 return tag_ptr(ret_conv, true);
21847 int64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
21848 LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(arg);
21849 int64_t ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
21853 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint64_t orig) {
21854 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(orig);
21855 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21856 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
21857 return tag_ptr(ret_conv, true);
21860 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint64_t o) {
21861 LDKGossipTimestampFilter o_conv;
21862 o_conv.inner = untag_ptr(o);
21863 o_conv.is_owned = ptr_is_owned(o);
21864 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21865 o_conv = GossipTimestampFilter_clone(&o_conv);
21866 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21867 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
21868 return tag_ptr(ret_conv, true);
21871 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint64_t e) {
21872 void* e_ptr = untag_ptr(e);
21873 CHECK_ACCESS(e_ptr);
21874 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21875 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21876 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21877 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
21878 return tag_ptr(ret_conv, true);
21881 jboolean __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint64_t o) {
21882 LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(o);
21883 jboolean ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
21887 void __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_free"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint64_t _res) {
21888 if (!ptr_is_owned(_res)) return;
21889 void* _res_ptr = untag_ptr(_res);
21890 CHECK_ACCESS(_res_ptr);
21891 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(_res_ptr);
21892 FREE(untag_ptr(_res));
21893 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
21896 static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
21897 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21898 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
21899 return tag_ptr(ret_conv, true);
21901 int64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint64_t arg) {
21902 LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(arg);
21903 int64_t ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
21907 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint64_t orig) {
21908 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(orig);
21909 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21910 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
21911 return tag_ptr(ret_conv, true);
21914 uint64_t __attribute__((export_name("TS_COption_FilterZ_some"))) TS_COption_FilterZ_some(uint64_t o) {
21915 void* o_ptr = untag_ptr(o);
21916 CHECK_ACCESS(o_ptr);
21917 LDKFilter o_conv = *(LDKFilter*)(o_ptr);
21918 if (o_conv.free == LDKFilter_JCalls_free) {
21919 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21920 LDKFilter_JCalls_cloned(&o_conv);
21922 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
21923 *ret_copy = COption_FilterZ_some(o_conv);
21924 uint64_t ret_ref = tag_ptr(ret_copy, true);
21928 uint64_t __attribute__((export_name("TS_COption_FilterZ_none"))) TS_COption_FilterZ_none() {
21929 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
21930 *ret_copy = COption_FilterZ_none();
21931 uint64_t ret_ref = tag_ptr(ret_copy, true);
21935 void __attribute__((export_name("TS_COption_FilterZ_free"))) TS_COption_FilterZ_free(uint64_t _res) {
21936 if (!ptr_is_owned(_res)) return;
21937 void* _res_ptr = untag_ptr(_res);
21938 CHECK_ACCESS(_res_ptr);
21939 LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(_res_ptr);
21940 FREE(untag_ptr(_res));
21941 COption_FilterZ_free(_res_conv);
21944 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_ok"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint64_t o) {
21945 LDKLockedChannelMonitor o_conv;
21946 o_conv.inner = untag_ptr(o);
21947 o_conv.is_owned = ptr_is_owned(o);
21948 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21949 // WARNING: we need a move here but no clone is available for LDKLockedChannelMonitor
21951 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
21952 *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
21953 return tag_ptr(ret_conv, true);
21956 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_err"))) TS_CResult_LockedChannelMonitorNoneZ_err() {
21957 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
21958 *ret_conv = CResult_LockedChannelMonitorNoneZ_err();
21959 return tag_ptr(ret_conv, true);
21962 jboolean __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_is_ok"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint64_t o) {
21963 LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(o);
21964 jboolean ret_conv = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
21968 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_free"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint64_t _res) {
21969 if (!ptr_is_owned(_res)) return;
21970 void* _res_ptr = untag_ptr(_res);
21971 CHECK_ACCESS(_res_ptr);
21972 LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(_res_ptr);
21973 FREE(untag_ptr(_res));
21974 CResult_LockedChannelMonitorNoneZ_free(_res_conv);
21977 void __attribute__((export_name("TS_CVec_OutPointZ_free"))) TS_CVec_OutPointZ_free(uint64_tArray _res) {
21978 LDKCVec_OutPointZ _res_constr;
21979 _res_constr.datalen = _res->arr_len;
21980 if (_res_constr.datalen > 0)
21981 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements");
21983 _res_constr.data = NULL;
21984 uint64_t* _res_vals = _res->elems;
21985 for (size_t k = 0; k < _res_constr.datalen; k++) {
21986 uint64_t _res_conv_10 = _res_vals[k];
21987 LDKOutPoint _res_conv_10_conv;
21988 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
21989 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
21990 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
21991 _res_constr.data[k] = _res_conv_10_conv;
21994 CVec_OutPointZ_free(_res_constr);
21997 void __attribute__((export_name("TS_CVec_MonitorUpdateIdZ_free"))) TS_CVec_MonitorUpdateIdZ_free(uint64_tArray _res) {
21998 LDKCVec_MonitorUpdateIdZ _res_constr;
21999 _res_constr.datalen = _res->arr_len;
22000 if (_res_constr.datalen > 0)
22001 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
22003 _res_constr.data = NULL;
22004 uint64_t* _res_vals = _res->elems;
22005 for (size_t r = 0; r < _res_constr.datalen; r++) {
22006 uint64_t _res_conv_17 = _res_vals[r];
22007 LDKMonitorUpdateId _res_conv_17_conv;
22008 _res_conv_17_conv.inner = untag_ptr(_res_conv_17);
22009 _res_conv_17_conv.is_owned = ptr_is_owned(_res_conv_17);
22010 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_17_conv);
22011 _res_constr.data[r] = _res_conv_17_conv;
22014 CVec_MonitorUpdateIdZ_free(_res_constr);
22017 static inline uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg) {
22018 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
22019 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(arg);
22020 return tag_ptr(ret_conv, true);
22022 int64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(uint64_t arg) {
22023 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* arg_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(arg);
22024 int64_t ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg_conv);
22028 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(uint64_t orig) {
22029 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* orig_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(orig);
22030 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
22031 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig_conv);
22032 return tag_ptr(ret_conv, true);
22035 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(uint64_t a, uint64_tArray b) {
22036 LDKOutPoint a_conv;
22037 a_conv.inner = untag_ptr(a);
22038 a_conv.is_owned = ptr_is_owned(a);
22039 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22040 a_conv = OutPoint_clone(&a_conv);
22041 LDKCVec_MonitorUpdateIdZ b_constr;
22042 b_constr.datalen = b->arr_len;
22043 if (b_constr.datalen > 0)
22044 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
22046 b_constr.data = NULL;
22047 uint64_t* b_vals = b->elems;
22048 for (size_t r = 0; r < b_constr.datalen; r++) {
22049 uint64_t b_conv_17 = b_vals[r];
22050 LDKMonitorUpdateId b_conv_17_conv;
22051 b_conv_17_conv.inner = untag_ptr(b_conv_17);
22052 b_conv_17_conv.is_owned = ptr_is_owned(b_conv_17);
22053 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv_17_conv);
22054 b_conv_17_conv = MonitorUpdateId_clone(&b_conv_17_conv);
22055 b_constr.data[r] = b_conv_17_conv;
22058 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
22059 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a_conv, b_constr);
22060 return tag_ptr(ret_conv, true);
22063 void __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(uint64_t _res) {
22064 if (!ptr_is_owned(_res)) return;
22065 void* _res_ptr = untag_ptr(_res);
22066 CHECK_ACCESS(_res_ptr);
22067 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_ptr);
22068 FREE(untag_ptr(_res));
22069 C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res_conv);
22072 void __attribute__((export_name("TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free"))) TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(uint64_tArray _res) {
22073 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res_constr;
22074 _res_constr.datalen = _res->arr_len;
22075 if (_res_constr.datalen > 0)
22076 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ Elements");
22078 _res_constr.data = NULL;
22079 uint64_t* _res_vals = _res->elems;
22080 for (size_t p = 0; p < _res_constr.datalen; p++) {
22081 uint64_t _res_conv_41 = _res_vals[p];
22082 void* _res_conv_41_ptr = untag_ptr(_res_conv_41);
22083 CHECK_ACCESS(_res_conv_41_ptr);
22084 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv_41_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_conv_41_ptr);
22085 FREE(untag_ptr(_res_conv_41));
22086 _res_constr.data[p] = _res_conv_41_conv;
22089 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res_constr);
22092 void __attribute__((export_name("TS_CVec_PhantomRouteHintsZ_free"))) TS_CVec_PhantomRouteHintsZ_free(uint64_tArray _res) {
22093 LDKCVec_PhantomRouteHintsZ _res_constr;
22094 _res_constr.datalen = _res->arr_len;
22095 if (_res_constr.datalen > 0)
22096 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
22098 _res_constr.data = NULL;
22099 uint64_t* _res_vals = _res->elems;
22100 for (size_t t = 0; t < _res_constr.datalen; t++) {
22101 uint64_t _res_conv_19 = _res_vals[t];
22102 LDKPhantomRouteHints _res_conv_19_conv;
22103 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
22104 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
22105 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
22106 _res_constr.data[t] = _res_conv_19_conv;
22109 CVec_PhantomRouteHintsZ_free(_res_constr);
22112 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_ok(uint64_t o) {
22114 o_conv.inner = untag_ptr(o);
22115 o_conv.is_owned = ptr_is_owned(o);
22116 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22117 o_conv = Invoice_clone(&o_conv);
22118 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22119 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
22120 return tag_ptr(ret_conv, true);
22123 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint64_t e) {
22124 void* e_ptr = untag_ptr(e);
22125 CHECK_ACCESS(e_ptr);
22126 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(e_ptr);
22127 e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)untag_ptr(e));
22128 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22129 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
22130 return tag_ptr(ret_conv, true);
22133 jboolean __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_is_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint64_t o) {
22134 LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(o);
22135 jboolean ret_conv = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
22139 void __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_free"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint64_t _res) {
22140 if (!ptr_is_owned(_res)) return;
22141 void* _res_ptr = untag_ptr(_res);
22142 CHECK_ACCESS(_res_ptr);
22143 LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(_res_ptr);
22144 FREE(untag_ptr(_res));
22145 CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
22148 static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
22149 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22150 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
22151 return tag_ptr(ret_conv, true);
22153 int64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint64_t arg) {
22154 LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(arg);
22155 int64_t ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
22159 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint64_t orig) {
22160 LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(orig);
22161 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22162 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
22163 return tag_ptr(ret_conv, true);
22166 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_ok"))) TS_CResult_SiPrefixParseErrorZ_ok(uint32_t o) {
22167 LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
22168 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22169 *ret_conv = CResult_SiPrefixParseErrorZ_ok(o_conv);
22170 return tag_ptr(ret_conv, true);
22173 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_err"))) TS_CResult_SiPrefixParseErrorZ_err(uint64_t e) {
22174 void* e_ptr = untag_ptr(e);
22175 CHECK_ACCESS(e_ptr);
22176 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
22177 e_conv = ParseError_clone((LDKParseError*)untag_ptr(e));
22178 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22179 *ret_conv = CResult_SiPrefixParseErrorZ_err(e_conv);
22180 return tag_ptr(ret_conv, true);
22183 jboolean __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_is_ok"))) TS_CResult_SiPrefixParseErrorZ_is_ok(uint64_t o) {
22184 LDKCResult_SiPrefixParseErrorZ* o_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(o);
22185 jboolean ret_conv = CResult_SiPrefixParseErrorZ_is_ok(o_conv);
22189 void __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_free"))) TS_CResult_SiPrefixParseErrorZ_free(uint64_t _res) {
22190 if (!ptr_is_owned(_res)) return;
22191 void* _res_ptr = untag_ptr(_res);
22192 CHECK_ACCESS(_res_ptr);
22193 LDKCResult_SiPrefixParseErrorZ _res_conv = *(LDKCResult_SiPrefixParseErrorZ*)(_res_ptr);
22194 FREE(untag_ptr(_res));
22195 CResult_SiPrefixParseErrorZ_free(_res_conv);
22198 static inline uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg) {
22199 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22200 *ret_conv = CResult_SiPrefixParseErrorZ_clone(arg);
22201 return tag_ptr(ret_conv, true);
22203 int64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone_ptr"))) TS_CResult_SiPrefixParseErrorZ_clone_ptr(uint64_t arg) {
22204 LDKCResult_SiPrefixParseErrorZ* arg_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(arg);
22205 int64_t ret_conv = CResult_SiPrefixParseErrorZ_clone_ptr(arg_conv);
22209 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone"))) TS_CResult_SiPrefixParseErrorZ_clone(uint64_t orig) {
22210 LDKCResult_SiPrefixParseErrorZ* orig_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(orig);
22211 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22212 *ret_conv = CResult_SiPrefixParseErrorZ_clone(orig_conv);
22213 return tag_ptr(ret_conv, true);
22216 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_ok(uint64_t o) {
22218 o_conv.inner = untag_ptr(o);
22219 o_conv.is_owned = ptr_is_owned(o);
22220 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22221 o_conv = Invoice_clone(&o_conv);
22222 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22223 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_ok(o_conv);
22224 return tag_ptr(ret_conv, true);
22227 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_err(uint64_t e) {
22228 void* e_ptr = untag_ptr(e);
22229 CHECK_ACCESS(e_ptr);
22230 LDKParseOrSemanticError e_conv = *(LDKParseOrSemanticError*)(e_ptr);
22231 e_conv = ParseOrSemanticError_clone((LDKParseOrSemanticError*)untag_ptr(e));
22232 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22233 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_err(e_conv);
22234 return tag_ptr(ret_conv, true);
22237 jboolean __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(uint64_t o) {
22238 LDKCResult_InvoiceParseOrSemanticErrorZ* o_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(o);
22239 jboolean ret_conv = CResult_InvoiceParseOrSemanticErrorZ_is_ok(o_conv);
22243 void __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_free"))) TS_CResult_InvoiceParseOrSemanticErrorZ_free(uint64_t _res) {
22244 if (!ptr_is_owned(_res)) return;
22245 void* _res_ptr = untag_ptr(_res);
22246 CHECK_ACCESS(_res_ptr);
22247 LDKCResult_InvoiceParseOrSemanticErrorZ _res_conv = *(LDKCResult_InvoiceParseOrSemanticErrorZ*)(_res_ptr);
22248 FREE(untag_ptr(_res));
22249 CResult_InvoiceParseOrSemanticErrorZ_free(_res_conv);
22252 static inline uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg) {
22253 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22254 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(arg);
22255 return tag_ptr(ret_conv, true);
22257 int64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(uint64_t arg) {
22258 LDKCResult_InvoiceParseOrSemanticErrorZ* arg_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(arg);
22259 int64_t ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg_conv);
22263 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone(uint64_t orig) {
22264 LDKCResult_InvoiceParseOrSemanticErrorZ* orig_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(orig);
22265 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22266 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(orig_conv);
22267 return tag_ptr(ret_conv, true);
22270 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_ok(uint64_t o) {
22271 LDKSignedRawInvoice o_conv;
22272 o_conv.inner = untag_ptr(o);
22273 o_conv.is_owned = ptr_is_owned(o);
22274 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22275 o_conv = SignedRawInvoice_clone(&o_conv);
22276 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22277 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_ok(o_conv);
22278 return tag_ptr(ret_conv, true);
22281 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_err(uint64_t e) {
22282 void* e_ptr = untag_ptr(e);
22283 CHECK_ACCESS(e_ptr);
22284 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
22285 e_conv = ParseError_clone((LDKParseError*)untag_ptr(e));
22286 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22287 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_err(e_conv);
22288 return tag_ptr(ret_conv, true);
22291 jboolean __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_is_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(uint64_t o) {
22292 LDKCResult_SignedRawInvoiceParseErrorZ* o_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(o);
22293 jboolean ret_conv = CResult_SignedRawInvoiceParseErrorZ_is_ok(o_conv);
22297 void __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_free"))) TS_CResult_SignedRawInvoiceParseErrorZ_free(uint64_t _res) {
22298 if (!ptr_is_owned(_res)) return;
22299 void* _res_ptr = untag_ptr(_res);
22300 CHECK_ACCESS(_res_ptr);
22301 LDKCResult_SignedRawInvoiceParseErrorZ _res_conv = *(LDKCResult_SignedRawInvoiceParseErrorZ*)(_res_ptr);
22302 FREE(untag_ptr(_res));
22303 CResult_SignedRawInvoiceParseErrorZ_free(_res_conv);
22306 static inline uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg) {
22307 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22308 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(arg);
22309 return tag_ptr(ret_conv, true);
22311 int64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(uint64_t arg) {
22312 LDKCResult_SignedRawInvoiceParseErrorZ* arg_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(arg);
22313 int64_t ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg_conv);
22317 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone(uint64_t orig) {
22318 LDKCResult_SignedRawInvoiceParseErrorZ* orig_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(orig);
22319 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22320 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(orig_conv);
22321 return tag_ptr(ret_conv, true);
22324 static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
22325 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22326 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
22327 return tag_ptr(ret_conv, true);
22329 int64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint64_t arg) {
22330 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(arg);
22331 int64_t ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
22335 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint64_t orig) {
22336 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(orig);
22337 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22338 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
22339 return tag_ptr(ret_conv, true);
22342 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint64_t a, int8_tArray b, uint64_t c) {
22343 LDKRawInvoice a_conv;
22344 a_conv.inner = untag_ptr(a);
22345 a_conv.is_owned = ptr_is_owned(a);
22346 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22347 a_conv = RawInvoice_clone(&a_conv);
22348 LDKThirtyTwoBytes b_ref;
22349 CHECK(b->arr_len == 32);
22350 memcpy(b_ref.data, b->elems, 32); FREE(b);
22351 LDKInvoiceSignature c_conv;
22352 c_conv.inner = untag_ptr(c);
22353 c_conv.is_owned = ptr_is_owned(c);
22354 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
22355 c_conv = InvoiceSignature_clone(&c_conv);
22356 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22357 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
22358 return tag_ptr(ret_conv, true);
22361 void __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint64_t _res) {
22362 if (!ptr_is_owned(_res)) return;
22363 void* _res_ptr = untag_ptr(_res);
22364 CHECK_ACCESS(_res_ptr);
22365 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(_res_ptr);
22366 FREE(untag_ptr(_res));
22367 C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
22370 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_ok"))) TS_CResult_PayeePubKeyErrorZ_ok(uint64_t o) {
22371 LDKPayeePubKey o_conv;
22372 o_conv.inner = untag_ptr(o);
22373 o_conv.is_owned = ptr_is_owned(o);
22374 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22375 o_conv = PayeePubKey_clone(&o_conv);
22376 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22377 *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
22378 return tag_ptr(ret_conv, true);
22381 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_err"))) TS_CResult_PayeePubKeyErrorZ_err(uint32_t e) {
22382 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
22383 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22384 *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
22385 return tag_ptr(ret_conv, true);
22388 jboolean __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_is_ok"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint64_t o) {
22389 LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(o);
22390 jboolean ret_conv = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
22394 void __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_free"))) TS_CResult_PayeePubKeyErrorZ_free(uint64_t _res) {
22395 if (!ptr_is_owned(_res)) return;
22396 void* _res_ptr = untag_ptr(_res);
22397 CHECK_ACCESS(_res_ptr);
22398 LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(_res_ptr);
22399 FREE(untag_ptr(_res));
22400 CResult_PayeePubKeyErrorZ_free(_res_conv);
22403 static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
22404 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22405 *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
22406 return tag_ptr(ret_conv, true);
22408 int64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone_ptr"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint64_t arg) {
22409 LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(arg);
22410 int64_t ret_conv = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
22414 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone"))) TS_CResult_PayeePubKeyErrorZ_clone(uint64_t orig) {
22415 LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(orig);
22416 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22417 *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
22418 return tag_ptr(ret_conv, true);
22421 void __attribute__((export_name("TS_CVec_PrivateRouteZ_free"))) TS_CVec_PrivateRouteZ_free(uint64_tArray _res) {
22422 LDKCVec_PrivateRouteZ _res_constr;
22423 _res_constr.datalen = _res->arr_len;
22424 if (_res_constr.datalen > 0)
22425 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
22427 _res_constr.data = NULL;
22428 uint64_t* _res_vals = _res->elems;
22429 for (size_t o = 0; o < _res_constr.datalen; o++) {
22430 uint64_t _res_conv_14 = _res_vals[o];
22431 LDKPrivateRoute _res_conv_14_conv;
22432 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
22433 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
22434 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
22435 _res_constr.data[o] = _res_conv_14_conv;
22438 CVec_PrivateRouteZ_free(_res_constr);
22441 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint64_t o) {
22442 LDKPositiveTimestamp o_conv;
22443 o_conv.inner = untag_ptr(o);
22444 o_conv.is_owned = ptr_is_owned(o);
22445 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22446 o_conv = PositiveTimestamp_clone(&o_conv);
22447 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22448 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
22449 return tag_ptr(ret_conv, true);
22452 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_err"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
22453 LDKCreationError e_conv = LDKCreationError_from_js(e);
22454 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22455 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
22456 return tag_ptr(ret_conv, true);
22459 jboolean __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_is_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint64_t o) {
22460 LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(o);
22461 jboolean ret_conv = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
22465 void __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_free"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint64_t _res) {
22466 if (!ptr_is_owned(_res)) return;
22467 void* _res_ptr = untag_ptr(_res);
22468 CHECK_ACCESS(_res_ptr);
22469 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(_res_ptr);
22470 FREE(untag_ptr(_res));
22471 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
22474 static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
22475 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22476 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
22477 return tag_ptr(ret_conv, true);
22479 int64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint64_t arg) {
22480 LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(arg);
22481 int64_t ret_conv = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
22485 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint64_t orig) {
22486 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(orig);
22487 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22488 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
22489 return tag_ptr(ret_conv, true);
22492 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_ok"))) TS_CResult_NoneSemanticErrorZ_ok() {
22493 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22494 *ret_conv = CResult_NoneSemanticErrorZ_ok();
22495 return tag_ptr(ret_conv, true);
22498 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_err"))) TS_CResult_NoneSemanticErrorZ_err(uint32_t e) {
22499 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
22500 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22501 *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
22502 return tag_ptr(ret_conv, true);
22505 jboolean __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_is_ok"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint64_t o) {
22506 LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(o);
22507 jboolean ret_conv = CResult_NoneSemanticErrorZ_is_ok(o_conv);
22511 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_free"))) TS_CResult_NoneSemanticErrorZ_free(uint64_t _res) {
22512 if (!ptr_is_owned(_res)) return;
22513 void* _res_ptr = untag_ptr(_res);
22514 CHECK_ACCESS(_res_ptr);
22515 LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(_res_ptr);
22516 FREE(untag_ptr(_res));
22517 CResult_NoneSemanticErrorZ_free(_res_conv);
22520 static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
22521 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22522 *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
22523 return tag_ptr(ret_conv, true);
22525 int64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone_ptr"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint64_t arg) {
22526 LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(arg);
22527 int64_t ret_conv = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
22531 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone"))) TS_CResult_NoneSemanticErrorZ_clone(uint64_t orig) {
22532 LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(orig);
22533 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22534 *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
22535 return tag_ptr(ret_conv, true);
22538 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_ok"))) TS_CResult_InvoiceSemanticErrorZ_ok(uint64_t o) {
22540 o_conv.inner = untag_ptr(o);
22541 o_conv.is_owned = ptr_is_owned(o);
22542 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22543 o_conv = Invoice_clone(&o_conv);
22544 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22545 *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
22546 return tag_ptr(ret_conv, true);
22549 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_err"))) TS_CResult_InvoiceSemanticErrorZ_err(uint32_t e) {
22550 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
22551 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22552 *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
22553 return tag_ptr(ret_conv, true);
22556 jboolean __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_is_ok"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint64_t o) {
22557 LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(o);
22558 jboolean ret_conv = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
22562 void __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_free"))) TS_CResult_InvoiceSemanticErrorZ_free(uint64_t _res) {
22563 if (!ptr_is_owned(_res)) return;
22564 void* _res_ptr = untag_ptr(_res);
22565 CHECK_ACCESS(_res_ptr);
22566 LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(_res_ptr);
22567 FREE(untag_ptr(_res));
22568 CResult_InvoiceSemanticErrorZ_free(_res_conv);
22571 static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
22572 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22573 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
22574 return tag_ptr(ret_conv, true);
22576 int64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint64_t arg) {
22577 LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(arg);
22578 int64_t ret_conv = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
22582 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint64_t orig) {
22583 LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(orig);
22584 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22585 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
22586 return tag_ptr(ret_conv, true);
22589 void __attribute__((export_name("TS_CVec_AddressZ_free"))) TS_CVec_AddressZ_free(ptrArray _res) {
22590 LDKCVec_AddressZ _res_constr;
22591 _res_constr.datalen = _res->arr_len;
22592 if (_res_constr.datalen > 0)
22593 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKStr), "LDKCVec_AddressZ Elements");
22595 _res_constr.data = NULL;
22596 jstring* _res_vals = (void*) _res->elems;
22597 for (size_t i = 0; i < _res_constr.datalen; i++) {
22598 jstring _res_conv_8 = _res_vals[i];
22599 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
22600 _res_constr.data[i] = dummy;
22603 CVec_AddressZ_free(_res_constr);
22606 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_ok"))) TS_CResult_DescriptionCreationErrorZ_ok(uint64_t o) {
22607 LDKDescription o_conv;
22608 o_conv.inner = untag_ptr(o);
22609 o_conv.is_owned = ptr_is_owned(o);
22610 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22611 o_conv = Description_clone(&o_conv);
22612 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22613 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
22614 return tag_ptr(ret_conv, true);
22617 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_err"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
22618 LDKCreationError e_conv = LDKCreationError_from_js(e);
22619 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22620 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
22621 return tag_ptr(ret_conv, true);
22624 jboolean __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_is_ok"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint64_t o) {
22625 LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(o);
22626 jboolean ret_conv = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
22630 void __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_free"))) TS_CResult_DescriptionCreationErrorZ_free(uint64_t _res) {
22631 if (!ptr_is_owned(_res)) return;
22632 void* _res_ptr = untag_ptr(_res);
22633 CHECK_ACCESS(_res_ptr);
22634 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(_res_ptr);
22635 FREE(untag_ptr(_res));
22636 CResult_DescriptionCreationErrorZ_free(_res_conv);
22639 static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
22640 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22641 *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
22642 return tag_ptr(ret_conv, true);
22644 int64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone_ptr"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint64_t arg) {
22645 LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(arg);
22646 int64_t ret_conv = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
22650 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone"))) TS_CResult_DescriptionCreationErrorZ_clone(uint64_t orig) {
22651 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(orig);
22652 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22653 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
22654 return tag_ptr(ret_conv, true);
22657 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_ok"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint64_t o) {
22658 LDKPrivateRoute o_conv;
22659 o_conv.inner = untag_ptr(o);
22660 o_conv.is_owned = ptr_is_owned(o);
22661 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22662 o_conv = PrivateRoute_clone(&o_conv);
22663 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22664 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
22665 return tag_ptr(ret_conv, true);
22668 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_err"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
22669 LDKCreationError e_conv = LDKCreationError_from_js(e);
22670 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22671 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
22672 return tag_ptr(ret_conv, true);
22675 jboolean __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_is_ok"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint64_t o) {
22676 LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(o);
22677 jboolean ret_conv = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
22681 void __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_free"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint64_t _res) {
22682 if (!ptr_is_owned(_res)) return;
22683 void* _res_ptr = untag_ptr(_res);
22684 CHECK_ACCESS(_res_ptr);
22685 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(_res_ptr);
22686 FREE(untag_ptr(_res));
22687 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
22690 static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
22691 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22692 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
22693 return tag_ptr(ret_conv, true);
22695 int64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone_ptr"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint64_t arg) {
22696 LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(arg);
22697 int64_t ret_conv = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
22701 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint64_t orig) {
22702 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(orig);
22703 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22704 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
22705 return tag_ptr(ret_conv, true);
22708 void __attribute__((export_name("TS_APIError_free"))) TS_APIError_free(uint64_t this_ptr) {
22709 if (!ptr_is_owned(this_ptr)) return;
22710 void* this_ptr_ptr = untag_ptr(this_ptr);
22711 CHECK_ACCESS(this_ptr_ptr);
22712 LDKAPIError this_ptr_conv = *(LDKAPIError*)(this_ptr_ptr);
22713 FREE(untag_ptr(this_ptr));
22714 APIError_free(this_ptr_conv);
22717 static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
22718 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22719 *ret_copy = APIError_clone(arg);
22720 uint64_t ret_ref = tag_ptr(ret_copy, true);
22723 int64_t __attribute__((export_name("TS_APIError_clone_ptr"))) TS_APIError_clone_ptr(uint64_t arg) {
22724 LDKAPIError* arg_conv = (LDKAPIError*)untag_ptr(arg);
22725 int64_t ret_conv = APIError_clone_ptr(arg_conv);
22729 uint64_t __attribute__((export_name("TS_APIError_clone"))) TS_APIError_clone(uint64_t orig) {
22730 LDKAPIError* orig_conv = (LDKAPIError*)untag_ptr(orig);
22731 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22732 *ret_copy = APIError_clone(orig_conv);
22733 uint64_t ret_ref = tag_ptr(ret_copy, true);
22737 uint64_t __attribute__((export_name("TS_APIError_apimisuse_error"))) TS_APIError_apimisuse_error(jstring err) {
22738 LDKStr err_conv = str_ref_to_owned_c(err);
22739 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22740 *ret_copy = APIError_apimisuse_error(err_conv);
22741 uint64_t ret_ref = tag_ptr(ret_copy, true);
22745 uint64_t __attribute__((export_name("TS_APIError_fee_rate_too_high"))) TS_APIError_fee_rate_too_high(jstring err, int32_t feerate) {
22746 LDKStr err_conv = str_ref_to_owned_c(err);
22747 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22748 *ret_copy = APIError_fee_rate_too_high(err_conv, feerate);
22749 uint64_t ret_ref = tag_ptr(ret_copy, true);
22753 uint64_t __attribute__((export_name("TS_APIError_invalid_route"))) TS_APIError_invalid_route(jstring err) {
22754 LDKStr err_conv = str_ref_to_owned_c(err);
22755 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22756 *ret_copy = APIError_invalid_route(err_conv);
22757 uint64_t ret_ref = tag_ptr(ret_copy, true);
22761 uint64_t __attribute__((export_name("TS_APIError_channel_unavailable"))) TS_APIError_channel_unavailable(jstring err) {
22762 LDKStr err_conv = str_ref_to_owned_c(err);
22763 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22764 *ret_copy = APIError_channel_unavailable(err_conv);
22765 uint64_t ret_ref = tag_ptr(ret_copy, true);
22769 uint64_t __attribute__((export_name("TS_APIError_monitor_update_in_progress"))) TS_APIError_monitor_update_in_progress() {
22770 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22771 *ret_copy = APIError_monitor_update_in_progress();
22772 uint64_t ret_ref = tag_ptr(ret_copy, true);
22776 uint64_t __attribute__((export_name("TS_APIError_incompatible_shutdown_script"))) TS_APIError_incompatible_shutdown_script(uint64_t script) {
22777 LDKShutdownScript script_conv;
22778 script_conv.inner = untag_ptr(script);
22779 script_conv.is_owned = ptr_is_owned(script);
22780 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
22781 script_conv = ShutdownScript_clone(&script_conv);
22782 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22783 *ret_copy = APIError_incompatible_shutdown_script(script_conv);
22784 uint64_t ret_ref = tag_ptr(ret_copy, true);
22788 jboolean __attribute__((export_name("TS_APIError_eq"))) TS_APIError_eq(uint64_t a, uint64_t b) {
22789 LDKAPIError* a_conv = (LDKAPIError*)untag_ptr(a);
22790 LDKAPIError* b_conv = (LDKAPIError*)untag_ptr(b);
22791 jboolean ret_conv = APIError_eq(a_conv, b_conv);
22795 int8_tArray __attribute__((export_name("TS_APIError_write"))) TS_APIError_write(uint64_t obj) {
22796 LDKAPIError* obj_conv = (LDKAPIError*)untag_ptr(obj);
22797 LDKCVec_u8Z ret_var = APIError_write(obj_conv);
22798 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22799 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22800 CVec_u8Z_free(ret_var);
22804 uint64_t __attribute__((export_name("TS_APIError_read"))) TS_APIError_read(int8_tArray ser) {
22805 LDKu8slice ser_ref;
22806 ser_ref.datalen = ser->arr_len;
22807 ser_ref.data = ser->elems;
22808 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
22809 *ret_conv = APIError_read(ser_ref);
22811 return tag_ptr(ret_conv, true);
22814 void __attribute__((export_name("TS_BigSize_free"))) TS_BigSize_free(uint64_t this_obj) {
22815 LDKBigSize this_obj_conv;
22816 this_obj_conv.inner = untag_ptr(this_obj);
22817 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22818 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22819 BigSize_free(this_obj_conv);
22822 int64_t __attribute__((export_name("TS_BigSize_get_a"))) TS_BigSize_get_a(uint64_t this_ptr) {
22823 LDKBigSize this_ptr_conv;
22824 this_ptr_conv.inner = untag_ptr(this_ptr);
22825 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22827 this_ptr_conv.is_owned = false;
22828 int64_t ret_conv = BigSize_get_a(&this_ptr_conv);
22832 void __attribute__((export_name("TS_BigSize_set_a"))) TS_BigSize_set_a(uint64_t this_ptr, int64_t val) {
22833 LDKBigSize this_ptr_conv;
22834 this_ptr_conv.inner = untag_ptr(this_ptr);
22835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22837 this_ptr_conv.is_owned = false;
22838 BigSize_set_a(&this_ptr_conv, val);
22841 uint64_t __attribute__((export_name("TS_BigSize_new"))) TS_BigSize_new(int64_t a_arg) {
22842 LDKBigSize ret_var = BigSize_new(a_arg);
22843 uint64_t ret_ref = 0;
22844 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22845 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22849 void __attribute__((export_name("TS_Hostname_free"))) TS_Hostname_free(uint64_t this_obj) {
22850 LDKHostname this_obj_conv;
22851 this_obj_conv.inner = untag_ptr(this_obj);
22852 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22854 Hostname_free(this_obj_conv);
22857 static inline uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg) {
22858 LDKHostname ret_var = Hostname_clone(arg);
22859 uint64_t ret_ref = 0;
22860 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22861 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22864 int64_t __attribute__((export_name("TS_Hostname_clone_ptr"))) TS_Hostname_clone_ptr(uint64_t arg) {
22865 LDKHostname arg_conv;
22866 arg_conv.inner = untag_ptr(arg);
22867 arg_conv.is_owned = ptr_is_owned(arg);
22868 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22869 arg_conv.is_owned = false;
22870 int64_t ret_conv = Hostname_clone_ptr(&arg_conv);
22874 uint64_t __attribute__((export_name("TS_Hostname_clone"))) TS_Hostname_clone(uint64_t orig) {
22875 LDKHostname orig_conv;
22876 orig_conv.inner = untag_ptr(orig);
22877 orig_conv.is_owned = ptr_is_owned(orig);
22878 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22879 orig_conv.is_owned = false;
22880 LDKHostname ret_var = Hostname_clone(&orig_conv);
22881 uint64_t ret_ref = 0;
22882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22883 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22887 jboolean __attribute__((export_name("TS_Hostname_eq"))) TS_Hostname_eq(uint64_t a, uint64_t b) {
22888 LDKHostname a_conv;
22889 a_conv.inner = untag_ptr(a);
22890 a_conv.is_owned = ptr_is_owned(a);
22891 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22892 a_conv.is_owned = false;
22893 LDKHostname b_conv;
22894 b_conv.inner = untag_ptr(b);
22895 b_conv.is_owned = ptr_is_owned(b);
22896 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
22897 b_conv.is_owned = false;
22898 jboolean ret_conv = Hostname_eq(&a_conv, &b_conv);
22902 int8_t __attribute__((export_name("TS_Hostname_len"))) TS_Hostname_len(uint64_t this_arg) {
22903 LDKHostname this_arg_conv;
22904 this_arg_conv.inner = untag_ptr(this_arg);
22905 this_arg_conv.is_owned = ptr_is_owned(this_arg);
22906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
22907 this_arg_conv.is_owned = false;
22908 int8_t ret_conv = Hostname_len(&this_arg_conv);
22912 uint64_t __attribute__((export_name("TS_sign"))) TS_sign(int8_tArray msg, int8_tArray sk) {
22913 LDKu8slice msg_ref;
22914 msg_ref.datalen = msg->arr_len;
22915 msg_ref.data = msg->elems;
22916 uint8_t sk_arr[32];
22917 CHECK(sk->arr_len == 32);
22918 memcpy(sk_arr, sk->elems, 32); FREE(sk);
22919 uint8_t (*sk_ref)[32] = &sk_arr;
22920 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
22921 *ret_conv = sign(msg_ref, sk_ref);
22923 return tag_ptr(ret_conv, true);
22926 uint64_t __attribute__((export_name("TS_recover_pk"))) TS_recover_pk(int8_tArray msg, jstring sig) {
22927 LDKu8slice msg_ref;
22928 msg_ref.datalen = msg->arr_len;
22929 msg_ref.data = msg->elems;
22930 LDKStr sig_conv = str_ref_to_owned_c(sig);
22931 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
22932 *ret_conv = recover_pk(msg_ref, sig_conv);
22934 return tag_ptr(ret_conv, true);
22937 jboolean __attribute__((export_name("TS_verify"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
22938 LDKu8slice msg_ref;
22939 msg_ref.datalen = msg->arr_len;
22940 msg_ref.data = msg->elems;
22941 LDKStr sig_conv = str_ref_to_owned_c(sig);
22942 LDKPublicKey pk_ref;
22943 CHECK(pk->arr_len == 33);
22944 memcpy(pk_ref.compressed_form, pk->elems, 33); FREE(pk);
22945 jboolean ret_conv = verify(msg_ref, sig_conv, pk_ref);
22950 int8_tArray __attribute__((export_name("TS_construct_invoice_preimage"))) TS_construct_invoice_preimage(int8_tArray hrp_bytes, ptrArray data_without_signature) {
22951 LDKu8slice hrp_bytes_ref;
22952 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
22953 hrp_bytes_ref.data = hrp_bytes->elems;
22954 LDKCVec_U5Z data_without_signature_constr;
22955 data_without_signature_constr.datalen = data_without_signature->arr_len;
22956 if (data_without_signature_constr.datalen > 0)
22957 data_without_signature_constr.data = MALLOC(data_without_signature_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
22959 data_without_signature_constr.data = NULL;
22960 int8_t* data_without_signature_vals = (void*) data_without_signature->elems;
22961 for (size_t h = 0; h < data_without_signature_constr.datalen; h++) {
22962 int8_t data_without_signature_conv_7 = data_without_signature_vals[h];
22964 data_without_signature_constr.data[h] = (LDKU5){ ._0 = data_without_signature_conv_7 };
22966 FREE(data_without_signature);
22967 LDKCVec_u8Z ret_var = construct_invoice_preimage(hrp_bytes_ref, data_without_signature_constr);
22968 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22969 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22970 CVec_u8Z_free(ret_var);
22975 void __attribute__((export_name("TS_Persister_free"))) TS_Persister_free(uint64_t this_ptr) {
22976 if (!ptr_is_owned(this_ptr)) return;
22977 void* this_ptr_ptr = untag_ptr(this_ptr);
22978 CHECK_ACCESS(this_ptr_ptr);
22979 LDKPersister this_ptr_conv = *(LDKPersister*)(this_ptr_ptr);
22980 FREE(untag_ptr(this_ptr));
22981 Persister_free(this_ptr_conv);
22984 void __attribute__((export_name("TS_UntrustedString_free"))) TS_UntrustedString_free(uint64_t this_obj) {
22985 LDKUntrustedString this_obj_conv;
22986 this_obj_conv.inner = untag_ptr(this_obj);
22987 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22988 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22989 UntrustedString_free(this_obj_conv);
22992 jstring __attribute__((export_name("TS_UntrustedString_get_a"))) TS_UntrustedString_get_a(uint64_t this_ptr) {
22993 LDKUntrustedString this_ptr_conv;
22994 this_ptr_conv.inner = untag_ptr(this_ptr);
22995 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22997 this_ptr_conv.is_owned = false;
22998 LDKStr ret_str = UntrustedString_get_a(&this_ptr_conv);
22999 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23004 void __attribute__((export_name("TS_UntrustedString_set_a"))) TS_UntrustedString_set_a(uint64_t this_ptr, jstring val) {
23005 LDKUntrustedString this_ptr_conv;
23006 this_ptr_conv.inner = untag_ptr(this_ptr);
23007 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23009 this_ptr_conv.is_owned = false;
23010 LDKStr val_conv = str_ref_to_owned_c(val);
23011 UntrustedString_set_a(&this_ptr_conv, val_conv);
23014 uint64_t __attribute__((export_name("TS_UntrustedString_new"))) TS_UntrustedString_new(jstring a_arg) {
23015 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
23016 LDKUntrustedString ret_var = UntrustedString_new(a_arg_conv);
23017 uint64_t ret_ref = 0;
23018 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23019 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23023 static inline uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg) {
23024 LDKUntrustedString ret_var = UntrustedString_clone(arg);
23025 uint64_t ret_ref = 0;
23026 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23027 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23030 int64_t __attribute__((export_name("TS_UntrustedString_clone_ptr"))) TS_UntrustedString_clone_ptr(uint64_t arg) {
23031 LDKUntrustedString arg_conv;
23032 arg_conv.inner = untag_ptr(arg);
23033 arg_conv.is_owned = ptr_is_owned(arg);
23034 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23035 arg_conv.is_owned = false;
23036 int64_t ret_conv = UntrustedString_clone_ptr(&arg_conv);
23040 uint64_t __attribute__((export_name("TS_UntrustedString_clone"))) TS_UntrustedString_clone(uint64_t orig) {
23041 LDKUntrustedString orig_conv;
23042 orig_conv.inner = untag_ptr(orig);
23043 orig_conv.is_owned = ptr_is_owned(orig);
23044 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23045 orig_conv.is_owned = false;
23046 LDKUntrustedString ret_var = UntrustedString_clone(&orig_conv);
23047 uint64_t ret_ref = 0;
23048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23049 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23053 jboolean __attribute__((export_name("TS_UntrustedString_eq"))) TS_UntrustedString_eq(uint64_t a, uint64_t b) {
23054 LDKUntrustedString a_conv;
23055 a_conv.inner = untag_ptr(a);
23056 a_conv.is_owned = ptr_is_owned(a);
23057 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23058 a_conv.is_owned = false;
23059 LDKUntrustedString b_conv;
23060 b_conv.inner = untag_ptr(b);
23061 b_conv.is_owned = ptr_is_owned(b);
23062 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
23063 b_conv.is_owned = false;
23064 jboolean ret_conv = UntrustedString_eq(&a_conv, &b_conv);
23068 int8_tArray __attribute__((export_name("TS_UntrustedString_write"))) TS_UntrustedString_write(uint64_t obj) {
23069 LDKUntrustedString obj_conv;
23070 obj_conv.inner = untag_ptr(obj);
23071 obj_conv.is_owned = ptr_is_owned(obj);
23072 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
23073 obj_conv.is_owned = false;
23074 LDKCVec_u8Z ret_var = UntrustedString_write(&obj_conv);
23075 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23076 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23077 CVec_u8Z_free(ret_var);
23081 uint64_t __attribute__((export_name("TS_UntrustedString_read"))) TS_UntrustedString_read(int8_tArray ser) {
23082 LDKu8slice ser_ref;
23083 ser_ref.datalen = ser->arr_len;
23084 ser_ref.data = ser->elems;
23085 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
23086 *ret_conv = UntrustedString_read(ser_ref);
23088 return tag_ptr(ret_conv, true);
23091 void __attribute__((export_name("TS_PrintableString_free"))) TS_PrintableString_free(uint64_t this_obj) {
23092 LDKPrintableString this_obj_conv;
23093 this_obj_conv.inner = untag_ptr(this_obj);
23094 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23096 PrintableString_free(this_obj_conv);
23099 jstring __attribute__((export_name("TS_PrintableString_get_a"))) TS_PrintableString_get_a(uint64_t this_ptr) {
23100 LDKPrintableString this_ptr_conv;
23101 this_ptr_conv.inner = untag_ptr(this_ptr);
23102 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23104 this_ptr_conv.is_owned = false;
23105 LDKStr ret_str = PrintableString_get_a(&this_ptr_conv);
23106 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23111 void __attribute__((export_name("TS_PrintableString_set_a"))) TS_PrintableString_set_a(uint64_t this_ptr, jstring val) {
23112 LDKPrintableString this_ptr_conv;
23113 this_ptr_conv.inner = untag_ptr(this_ptr);
23114 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23116 this_ptr_conv.is_owned = false;
23117 LDKStr val_conv = str_ref_to_owned_c(val);
23118 PrintableString_set_a(&this_ptr_conv, val_conv);
23121 uint64_t __attribute__((export_name("TS_PrintableString_new"))) TS_PrintableString_new(jstring a_arg) {
23122 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
23123 LDKPrintableString ret_var = PrintableString_new(a_arg_conv);
23124 uint64_t ret_ref = 0;
23125 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23126 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23130 void __attribute__((export_name("TS_FutureCallback_free"))) TS_FutureCallback_free(uint64_t this_ptr) {
23131 if (!ptr_is_owned(this_ptr)) return;
23132 void* this_ptr_ptr = untag_ptr(this_ptr);
23133 CHECK_ACCESS(this_ptr_ptr);
23134 LDKFutureCallback this_ptr_conv = *(LDKFutureCallback*)(this_ptr_ptr);
23135 FREE(untag_ptr(this_ptr));
23136 FutureCallback_free(this_ptr_conv);
23139 void __attribute__((export_name("TS_Future_free"))) TS_Future_free(uint64_t this_obj) {
23140 LDKFuture this_obj_conv;
23141 this_obj_conv.inner = untag_ptr(this_obj);
23142 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23144 Future_free(this_obj_conv);
23147 static inline uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg) {
23148 LDKFuture ret_var = Future_clone(arg);
23149 uint64_t ret_ref = 0;
23150 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23151 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23154 int64_t __attribute__((export_name("TS_Future_clone_ptr"))) TS_Future_clone_ptr(uint64_t arg) {
23155 LDKFuture arg_conv;
23156 arg_conv.inner = untag_ptr(arg);
23157 arg_conv.is_owned = ptr_is_owned(arg);
23158 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23159 arg_conv.is_owned = false;
23160 int64_t ret_conv = Future_clone_ptr(&arg_conv);
23164 uint64_t __attribute__((export_name("TS_Future_clone"))) TS_Future_clone(uint64_t orig) {
23165 LDKFuture orig_conv;
23166 orig_conv.inner = untag_ptr(orig);
23167 orig_conv.is_owned = ptr_is_owned(orig);
23168 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23169 orig_conv.is_owned = false;
23170 LDKFuture ret_var = Future_clone(&orig_conv);
23171 uint64_t ret_ref = 0;
23172 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23173 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23177 void __attribute__((export_name("TS_Future_register_callback_fn"))) TS_Future_register_callback_fn(uint64_t this_arg, uint64_t callback) {
23178 LDKFuture this_arg_conv;
23179 this_arg_conv.inner = untag_ptr(this_arg);
23180 this_arg_conv.is_owned = ptr_is_owned(this_arg);
23181 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23182 this_arg_conv.is_owned = false;
23183 void* callback_ptr = untag_ptr(callback);
23184 CHECK_ACCESS(callback_ptr);
23185 LDKFutureCallback callback_conv = *(LDKFutureCallback*)(callback_ptr);
23186 if (callback_conv.free == LDKFutureCallback_JCalls_free) {
23187 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23188 LDKFutureCallback_JCalls_cloned(&callback_conv);
23190 Future_register_callback_fn(&this_arg_conv, callback_conv);
23193 uint32_t __attribute__((export_name("TS_Level_clone"))) TS_Level_clone(uint64_t orig) {
23194 LDKLevel* orig_conv = (LDKLevel*)untag_ptr(orig);
23195 uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
23199 uint32_t __attribute__((export_name("TS_Level_gossip"))) TS_Level_gossip() {
23200 uint32_t ret_conv = LDKLevel_to_js(Level_gossip());
23204 uint32_t __attribute__((export_name("TS_Level_trace"))) TS_Level_trace() {
23205 uint32_t ret_conv = LDKLevel_to_js(Level_trace());
23209 uint32_t __attribute__((export_name("TS_Level_debug"))) TS_Level_debug() {
23210 uint32_t ret_conv = LDKLevel_to_js(Level_debug());
23214 uint32_t __attribute__((export_name("TS_Level_info"))) TS_Level_info() {
23215 uint32_t ret_conv = LDKLevel_to_js(Level_info());
23219 uint32_t __attribute__((export_name("TS_Level_warn"))) TS_Level_warn() {
23220 uint32_t ret_conv = LDKLevel_to_js(Level_warn());
23224 uint32_t __attribute__((export_name("TS_Level_error"))) TS_Level_error() {
23225 uint32_t ret_conv = LDKLevel_to_js(Level_error());
23229 jboolean __attribute__((export_name("TS_Level_eq"))) TS_Level_eq(uint64_t a, uint64_t b) {
23230 LDKLevel* a_conv = (LDKLevel*)untag_ptr(a);
23231 LDKLevel* b_conv = (LDKLevel*)untag_ptr(b);
23232 jboolean ret_conv = Level_eq(a_conv, b_conv);
23236 int64_t __attribute__((export_name("TS_Level_hash"))) TS_Level_hash(uint64_t o) {
23237 LDKLevel* o_conv = (LDKLevel*)untag_ptr(o);
23238 int64_t ret_conv = Level_hash(o_conv);
23242 uint32_t __attribute__((export_name("TS_Level_max"))) TS_Level_max() {
23243 uint32_t ret_conv = LDKLevel_to_js(Level_max());
23247 void __attribute__((export_name("TS_Record_free"))) TS_Record_free(uint64_t this_obj) {
23248 LDKRecord this_obj_conv;
23249 this_obj_conv.inner = untag_ptr(this_obj);
23250 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23252 Record_free(this_obj_conv);
23255 uint32_t __attribute__((export_name("TS_Record_get_level"))) TS_Record_get_level(uint64_t this_ptr) {
23256 LDKRecord this_ptr_conv;
23257 this_ptr_conv.inner = untag_ptr(this_ptr);
23258 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23260 this_ptr_conv.is_owned = false;
23261 uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
23265 void __attribute__((export_name("TS_Record_set_level"))) TS_Record_set_level(uint64_t this_ptr, uint32_t val) {
23266 LDKRecord this_ptr_conv;
23267 this_ptr_conv.inner = untag_ptr(this_ptr);
23268 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23270 this_ptr_conv.is_owned = false;
23271 LDKLevel val_conv = LDKLevel_from_js(val);
23272 Record_set_level(&this_ptr_conv, val_conv);
23275 jstring __attribute__((export_name("TS_Record_get_args"))) TS_Record_get_args(uint64_t this_ptr) {
23276 LDKRecord this_ptr_conv;
23277 this_ptr_conv.inner = untag_ptr(this_ptr);
23278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23280 this_ptr_conv.is_owned = false;
23281 LDKStr ret_str = Record_get_args(&this_ptr_conv);
23282 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23287 void __attribute__((export_name("TS_Record_set_args"))) TS_Record_set_args(uint64_t this_ptr, jstring val) {
23288 LDKRecord this_ptr_conv;
23289 this_ptr_conv.inner = untag_ptr(this_ptr);
23290 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23292 this_ptr_conv.is_owned = false;
23293 LDKStr val_conv = str_ref_to_owned_c(val);
23294 Record_set_args(&this_ptr_conv, val_conv);
23297 jstring __attribute__((export_name("TS_Record_get_module_path"))) TS_Record_get_module_path(uint64_t this_ptr) {
23298 LDKRecord this_ptr_conv;
23299 this_ptr_conv.inner = untag_ptr(this_ptr);
23300 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23301 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23302 this_ptr_conv.is_owned = false;
23303 LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
23304 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23309 void __attribute__((export_name("TS_Record_set_module_path"))) TS_Record_set_module_path(uint64_t this_ptr, jstring val) {
23310 LDKRecord 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 LDKStr val_conv = str_ref_to_owned_c(val);
23316 Record_set_module_path(&this_ptr_conv, val_conv);
23319 jstring __attribute__((export_name("TS_Record_get_file"))) TS_Record_get_file(uint64_t this_ptr) {
23320 LDKRecord this_ptr_conv;
23321 this_ptr_conv.inner = untag_ptr(this_ptr);
23322 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23323 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23324 this_ptr_conv.is_owned = false;
23325 LDKStr ret_str = Record_get_file(&this_ptr_conv);
23326 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23331 void __attribute__((export_name("TS_Record_set_file"))) TS_Record_set_file(uint64_t this_ptr, jstring val) {
23332 LDKRecord this_ptr_conv;
23333 this_ptr_conv.inner = untag_ptr(this_ptr);
23334 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23336 this_ptr_conv.is_owned = false;
23337 LDKStr val_conv = str_ref_to_owned_c(val);
23338 Record_set_file(&this_ptr_conv, val_conv);
23341 int32_t __attribute__((export_name("TS_Record_get_line"))) TS_Record_get_line(uint64_t this_ptr) {
23342 LDKRecord this_ptr_conv;
23343 this_ptr_conv.inner = untag_ptr(this_ptr);
23344 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23346 this_ptr_conv.is_owned = false;
23347 int32_t ret_conv = Record_get_line(&this_ptr_conv);
23351 void __attribute__((export_name("TS_Record_set_line"))) TS_Record_set_line(uint64_t this_ptr, int32_t val) {
23352 LDKRecord this_ptr_conv;
23353 this_ptr_conv.inner = untag_ptr(this_ptr);
23354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23356 this_ptr_conv.is_owned = false;
23357 Record_set_line(&this_ptr_conv, val);
23360 static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
23361 LDKRecord ret_var = Record_clone(arg);
23362 uint64_t ret_ref = 0;
23363 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23364 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23367 int64_t __attribute__((export_name("TS_Record_clone_ptr"))) TS_Record_clone_ptr(uint64_t arg) {
23368 LDKRecord arg_conv;
23369 arg_conv.inner = untag_ptr(arg);
23370 arg_conv.is_owned = ptr_is_owned(arg);
23371 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23372 arg_conv.is_owned = false;
23373 int64_t ret_conv = Record_clone_ptr(&arg_conv);
23377 uint64_t __attribute__((export_name("TS_Record_clone"))) TS_Record_clone(uint64_t orig) {
23378 LDKRecord orig_conv;
23379 orig_conv.inner = untag_ptr(orig);
23380 orig_conv.is_owned = ptr_is_owned(orig);
23381 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23382 orig_conv.is_owned = false;
23383 LDKRecord ret_var = Record_clone(&orig_conv);
23384 uint64_t ret_ref = 0;
23385 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23386 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23390 void __attribute__((export_name("TS_Logger_free"))) TS_Logger_free(uint64_t this_ptr) {
23391 if (!ptr_is_owned(this_ptr)) return;
23392 void* this_ptr_ptr = untag_ptr(this_ptr);
23393 CHECK_ACCESS(this_ptr_ptr);
23394 LDKLogger this_ptr_conv = *(LDKLogger*)(this_ptr_ptr);
23395 FREE(untag_ptr(this_ptr));
23396 Logger_free(this_ptr_conv);
23399 void __attribute__((export_name("TS_ChannelHandshakeConfig_free"))) TS_ChannelHandshakeConfig_free(uint64_t this_obj) {
23400 LDKChannelHandshakeConfig this_obj_conv;
23401 this_obj_conv.inner = untag_ptr(this_obj);
23402 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23403 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23404 ChannelHandshakeConfig_free(this_obj_conv);
23407 int32_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_minimum_depth"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint64_t this_ptr) {
23408 LDKChannelHandshakeConfig this_ptr_conv;
23409 this_ptr_conv.inner = untag_ptr(this_ptr);
23410 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23412 this_ptr_conv.is_owned = false;
23413 int32_t ret_conv = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
23417 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_minimum_depth"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint64_t this_ptr, int32_t val) {
23418 LDKChannelHandshakeConfig this_ptr_conv;
23419 this_ptr_conv.inner = untag_ptr(this_ptr);
23420 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23421 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23422 this_ptr_conv.is_owned = false;
23423 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
23426 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_to_self_delay"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint64_t this_ptr) {
23427 LDKChannelHandshakeConfig this_ptr_conv;
23428 this_ptr_conv.inner = untag_ptr(this_ptr);
23429 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23430 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23431 this_ptr_conv.is_owned = false;
23432 int16_t ret_conv = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
23436 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) {
23437 LDKChannelHandshakeConfig this_ptr_conv;
23438 this_ptr_conv.inner = untag_ptr(this_ptr);
23439 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23440 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23441 this_ptr_conv.is_owned = false;
23442 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
23445 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint64_t this_ptr) {
23446 LDKChannelHandshakeConfig this_ptr_conv;
23447 this_ptr_conv.inner = untag_ptr(this_ptr);
23448 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23450 this_ptr_conv.is_owned = false;
23451 int64_t ret_conv = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
23455 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) {
23456 LDKChannelHandshakeConfig this_ptr_conv;
23457 this_ptr_conv.inner = untag_ptr(this_ptr);
23458 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23460 this_ptr_conv.is_owned = false;
23461 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
23464 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) {
23465 LDKChannelHandshakeConfig this_ptr_conv;
23466 this_ptr_conv.inner = untag_ptr(this_ptr);
23467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23469 this_ptr_conv.is_owned = false;
23470 int8_t ret_conv = ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv);
23474 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) {
23475 LDKChannelHandshakeConfig this_ptr_conv;
23476 this_ptr_conv.inner = untag_ptr(this_ptr);
23477 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23478 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23479 this_ptr_conv.is_owned = false;
23480 ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv, val);
23483 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(uint64_t this_ptr) {
23484 LDKChannelHandshakeConfig this_ptr_conv;
23485 this_ptr_conv.inner = untag_ptr(this_ptr);
23486 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23488 this_ptr_conv.is_owned = false;
23489 jboolean ret_conv = ChannelHandshakeConfig_get_negotiate_scid_privacy(&this_ptr_conv);
23493 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(uint64_t this_ptr, jboolean val) {
23494 LDKChannelHandshakeConfig this_ptr_conv;
23495 this_ptr_conv.inner = untag_ptr(this_ptr);
23496 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23497 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23498 this_ptr_conv.is_owned = false;
23499 ChannelHandshakeConfig_set_negotiate_scid_privacy(&this_ptr_conv, val);
23502 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_announced_channel"))) TS_ChannelHandshakeConfig_get_announced_channel(uint64_t this_ptr) {
23503 LDKChannelHandshakeConfig this_ptr_conv;
23504 this_ptr_conv.inner = untag_ptr(this_ptr);
23505 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23507 this_ptr_conv.is_owned = false;
23508 jboolean ret_conv = ChannelHandshakeConfig_get_announced_channel(&this_ptr_conv);
23512 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_announced_channel"))) TS_ChannelHandshakeConfig_set_announced_channel(uint64_t this_ptr, jboolean val) {
23513 LDKChannelHandshakeConfig this_ptr_conv;
23514 this_ptr_conv.inner = untag_ptr(this_ptr);
23515 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23516 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23517 this_ptr_conv.is_owned = false;
23518 ChannelHandshakeConfig_set_announced_channel(&this_ptr_conv, val);
23521 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(uint64_t this_ptr) {
23522 LDKChannelHandshakeConfig this_ptr_conv;
23523 this_ptr_conv.inner = untag_ptr(this_ptr);
23524 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23526 this_ptr_conv.is_owned = false;
23527 jboolean ret_conv = ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
23531 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(uint64_t this_ptr, jboolean val) {
23532 LDKChannelHandshakeConfig this_ptr_conv;
23533 this_ptr_conv.inner = untag_ptr(this_ptr);
23534 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23535 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23536 this_ptr_conv.is_owned = false;
23537 ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
23540 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) {
23541 LDKChannelHandshakeConfig this_ptr_conv;
23542 this_ptr_conv.inner = untag_ptr(this_ptr);
23543 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23545 this_ptr_conv.is_owned = false;
23546 int32_t ret_conv = ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(&this_ptr_conv);
23550 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) {
23551 LDKChannelHandshakeConfig this_ptr_conv;
23552 this_ptr_conv.inner = untag_ptr(this_ptr);
23553 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23555 this_ptr_conv.is_owned = false;
23556 ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(&this_ptr_conv, val);
23559 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs"))) TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(uint64_t this_ptr) {
23560 LDKChannelHandshakeConfig this_ptr_conv;
23561 this_ptr_conv.inner = untag_ptr(this_ptr);
23562 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23563 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23564 this_ptr_conv.is_owned = false;
23565 int16_t ret_conv = ChannelHandshakeConfig_get_our_max_accepted_htlcs(&this_ptr_conv);
23569 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs"))) TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
23570 LDKChannelHandshakeConfig this_ptr_conv;
23571 this_ptr_conv.inner = untag_ptr(this_ptr);
23572 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23574 this_ptr_conv.is_owned = false;
23575 ChannelHandshakeConfig_set_our_max_accepted_htlcs(&this_ptr_conv, val);
23578 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, int16_t our_max_accepted_htlcs_arg) {
23579 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, our_max_accepted_htlcs_arg);
23580 uint64_t ret_ref = 0;
23581 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23582 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23586 static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
23587 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
23588 uint64_t ret_ref = 0;
23589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23590 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23593 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone_ptr"))) TS_ChannelHandshakeConfig_clone_ptr(uint64_t arg) {
23594 LDKChannelHandshakeConfig arg_conv;
23595 arg_conv.inner = untag_ptr(arg);
23596 arg_conv.is_owned = ptr_is_owned(arg);
23597 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23598 arg_conv.is_owned = false;
23599 int64_t ret_conv = ChannelHandshakeConfig_clone_ptr(&arg_conv);
23603 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone"))) TS_ChannelHandshakeConfig_clone(uint64_t orig) {
23604 LDKChannelHandshakeConfig orig_conv;
23605 orig_conv.inner = untag_ptr(orig);
23606 orig_conv.is_owned = ptr_is_owned(orig);
23607 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23608 orig_conv.is_owned = false;
23609 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
23610 uint64_t ret_ref = 0;
23611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23612 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23616 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_default"))) TS_ChannelHandshakeConfig_default() {
23617 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
23618 uint64_t ret_ref = 0;
23619 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23620 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23624 void __attribute__((export_name("TS_ChannelHandshakeLimits_free"))) TS_ChannelHandshakeLimits_free(uint64_t this_obj) {
23625 LDKChannelHandshakeLimits this_obj_conv;
23626 this_obj_conv.inner = untag_ptr(this_obj);
23627 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23629 ChannelHandshakeLimits_free(this_obj_conv);
23632 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_funding_satoshis"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint64_t this_ptr) {
23633 LDKChannelHandshakeLimits this_ptr_conv;
23634 this_ptr_conv.inner = untag_ptr(this_ptr);
23635 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23636 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23637 this_ptr_conv.is_owned = false;
23638 int64_t ret_conv = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
23642 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_funding_satoshis"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint64_t this_ptr, int64_t val) {
23643 LDKChannelHandshakeLimits this_ptr_conv;
23644 this_ptr_conv.inner = untag_ptr(this_ptr);
23645 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23647 this_ptr_conv.is_owned = false;
23648 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
23651 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_funding_satoshis"))) TS_ChannelHandshakeLimits_get_max_funding_satoshis(uint64_t this_ptr) {
23652 LDKChannelHandshakeLimits this_ptr_conv;
23653 this_ptr_conv.inner = untag_ptr(this_ptr);
23654 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23656 this_ptr_conv.is_owned = false;
23657 int64_t ret_conv = ChannelHandshakeLimits_get_max_funding_satoshis(&this_ptr_conv);
23661 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_funding_satoshis"))) TS_ChannelHandshakeLimits_set_max_funding_satoshis(uint64_t this_ptr, int64_t val) {
23662 LDKChannelHandshakeLimits this_ptr_conv;
23663 this_ptr_conv.inner = untag_ptr(this_ptr);
23664 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23666 this_ptr_conv.is_owned = false;
23667 ChannelHandshakeLimits_set_max_funding_satoshis(&this_ptr_conv, val);
23670 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint64_t this_ptr) {
23671 LDKChannelHandshakeLimits this_ptr_conv;
23672 this_ptr_conv.inner = untag_ptr(this_ptr);
23673 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23675 this_ptr_conv.is_owned = false;
23676 int64_t ret_conv = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
23680 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) {
23681 LDKChannelHandshakeLimits this_ptr_conv;
23682 this_ptr_conv.inner = untag_ptr(this_ptr);
23683 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23685 this_ptr_conv.is_owned = false;
23686 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
23689 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) {
23690 LDKChannelHandshakeLimits this_ptr_conv;
23691 this_ptr_conv.inner = untag_ptr(this_ptr);
23692 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23693 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23694 this_ptr_conv.is_owned = false;
23695 int64_t ret_conv = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
23699 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) {
23700 LDKChannelHandshakeLimits this_ptr_conv;
23701 this_ptr_conv.inner = untag_ptr(this_ptr);
23702 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23704 this_ptr_conv.is_owned = false;
23705 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
23708 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint64_t this_ptr) {
23709 LDKChannelHandshakeLimits this_ptr_conv;
23710 this_ptr_conv.inner = untag_ptr(this_ptr);
23711 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23712 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23713 this_ptr_conv.is_owned = false;
23714 int64_t ret_conv = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
23718 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) {
23719 LDKChannelHandshakeLimits this_ptr_conv;
23720 this_ptr_conv.inner = untag_ptr(this_ptr);
23721 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23723 this_ptr_conv.is_owned = false;
23724 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
23727 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint64_t this_ptr) {
23728 LDKChannelHandshakeLimits this_ptr_conv;
23729 this_ptr_conv.inner = untag_ptr(this_ptr);
23730 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23732 this_ptr_conv.is_owned = false;
23733 int16_t ret_conv = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
23737 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) {
23738 LDKChannelHandshakeLimits this_ptr_conv;
23739 this_ptr_conv.inner = untag_ptr(this_ptr);
23740 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23742 this_ptr_conv.is_owned = false;
23743 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
23746 int32_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_minimum_depth"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint64_t this_ptr) {
23747 LDKChannelHandshakeLimits this_ptr_conv;
23748 this_ptr_conv.inner = untag_ptr(this_ptr);
23749 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23750 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23751 this_ptr_conv.is_owned = false;
23752 int32_t ret_conv = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
23756 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_minimum_depth"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint64_t this_ptr, int32_t val) {
23757 LDKChannelHandshakeLimits this_ptr_conv;
23758 this_ptr_conv.inner = untag_ptr(this_ptr);
23759 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23761 this_ptr_conv.is_owned = false;
23762 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
23765 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(uint64_t this_ptr) {
23766 LDKChannelHandshakeLimits this_ptr_conv;
23767 this_ptr_conv.inner = untag_ptr(this_ptr);
23768 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23770 this_ptr_conv.is_owned = false;
23771 jboolean ret_conv = ChannelHandshakeLimits_get_trust_own_funding_0conf(&this_ptr_conv);
23775 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(uint64_t this_ptr, jboolean val) {
23776 LDKChannelHandshakeLimits this_ptr_conv;
23777 this_ptr_conv.inner = untag_ptr(this_ptr);
23778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23780 this_ptr_conv.is_owned = false;
23781 ChannelHandshakeLimits_set_trust_own_funding_0conf(&this_ptr_conv, val);
23784 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint64_t this_ptr) {
23785 LDKChannelHandshakeLimits this_ptr_conv;
23786 this_ptr_conv.inner = untag_ptr(this_ptr);
23787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23789 this_ptr_conv.is_owned = false;
23790 jboolean ret_conv = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
23794 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint64_t this_ptr, jboolean val) {
23795 LDKChannelHandshakeLimits this_ptr_conv;
23796 this_ptr_conv.inner = untag_ptr(this_ptr);
23797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23799 this_ptr_conv.is_owned = false;
23800 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
23803 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_their_to_self_delay"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint64_t this_ptr) {
23804 LDKChannelHandshakeLimits this_ptr_conv;
23805 this_ptr_conv.inner = untag_ptr(this_ptr);
23806 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23808 this_ptr_conv.is_owned = false;
23809 int16_t ret_conv = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
23813 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) {
23814 LDKChannelHandshakeLimits this_ptr_conv;
23815 this_ptr_conv.inner = untag_ptr(this_ptr);
23816 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23818 this_ptr_conv.is_owned = false;
23819 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
23822 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) {
23823 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);
23824 uint64_t ret_ref = 0;
23825 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23826 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23830 static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
23831 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
23832 uint64_t ret_ref = 0;
23833 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23834 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23837 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone_ptr"))) TS_ChannelHandshakeLimits_clone_ptr(uint64_t arg) {
23838 LDKChannelHandshakeLimits arg_conv;
23839 arg_conv.inner = untag_ptr(arg);
23840 arg_conv.is_owned = ptr_is_owned(arg);
23841 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23842 arg_conv.is_owned = false;
23843 int64_t ret_conv = ChannelHandshakeLimits_clone_ptr(&arg_conv);
23847 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone"))) TS_ChannelHandshakeLimits_clone(uint64_t orig) {
23848 LDKChannelHandshakeLimits orig_conv;
23849 orig_conv.inner = untag_ptr(orig);
23850 orig_conv.is_owned = ptr_is_owned(orig);
23851 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23852 orig_conv.is_owned = false;
23853 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
23854 uint64_t ret_ref = 0;
23855 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23856 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23860 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_default"))) TS_ChannelHandshakeLimits_default() {
23861 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
23862 uint64_t ret_ref = 0;
23863 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23864 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23868 void __attribute__((export_name("TS_ChannelConfig_free"))) TS_ChannelConfig_free(uint64_t this_obj) {
23869 LDKChannelConfig this_obj_conv;
23870 this_obj_conv.inner = untag_ptr(this_obj);
23871 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23873 ChannelConfig_free(this_obj_conv);
23876 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_get_forwarding_fee_proportional_millionths(uint64_t this_ptr) {
23877 LDKChannelConfig this_ptr_conv;
23878 this_ptr_conv.inner = untag_ptr(this_ptr);
23879 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23881 this_ptr_conv.is_owned = false;
23882 int32_t ret_conv = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
23886 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) {
23887 LDKChannelConfig this_ptr_conv;
23888 this_ptr_conv.inner = untag_ptr(this_ptr);
23889 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23891 this_ptr_conv.is_owned = false;
23892 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
23895 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_base_msat"))) TS_ChannelConfig_get_forwarding_fee_base_msat(uint64_t this_ptr) {
23896 LDKChannelConfig this_ptr_conv;
23897 this_ptr_conv.inner = untag_ptr(this_ptr);
23898 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23900 this_ptr_conv.is_owned = false;
23901 int32_t ret_conv = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
23905 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) {
23906 LDKChannelConfig this_ptr_conv;
23907 this_ptr_conv.inner = untag_ptr(this_ptr);
23908 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23910 this_ptr_conv.is_owned = false;
23911 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
23914 int16_t __attribute__((export_name("TS_ChannelConfig_get_cltv_expiry_delta"))) TS_ChannelConfig_get_cltv_expiry_delta(uint64_t this_ptr) {
23915 LDKChannelConfig 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 int16_t ret_conv = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
23924 void __attribute__((export_name("TS_ChannelConfig_set_cltv_expiry_delta"))) TS_ChannelConfig_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
23925 LDKChannelConfig this_ptr_conv;
23926 this_ptr_conv.inner = untag_ptr(this_ptr);
23927 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23929 this_ptr_conv.is_owned = false;
23930 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
23933 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) {
23934 LDKChannelConfig this_ptr_conv;
23935 this_ptr_conv.inner = untag_ptr(this_ptr);
23936 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23938 this_ptr_conv.is_owned = false;
23939 int64_t ret_conv = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
23943 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) {
23944 LDKChannelConfig this_ptr_conv;
23945 this_ptr_conv.inner = untag_ptr(this_ptr);
23946 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23948 this_ptr_conv.is_owned = false;
23949 ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
23952 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) {
23953 LDKChannelConfig this_ptr_conv;
23954 this_ptr_conv.inner = untag_ptr(this_ptr);
23955 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23957 this_ptr_conv.is_owned = false;
23958 int64_t ret_conv = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
23962 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) {
23963 LDKChannelConfig this_ptr_conv;
23964 this_ptr_conv.inner = untag_ptr(this_ptr);
23965 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23966 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23967 this_ptr_conv.is_owned = false;
23968 ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
23971 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) {
23972 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);
23973 uint64_t ret_ref = 0;
23974 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23975 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23979 static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
23980 LDKChannelConfig ret_var = ChannelConfig_clone(arg);
23981 uint64_t ret_ref = 0;
23982 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23983 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23986 int64_t __attribute__((export_name("TS_ChannelConfig_clone_ptr"))) TS_ChannelConfig_clone_ptr(uint64_t arg) {
23987 LDKChannelConfig arg_conv;
23988 arg_conv.inner = untag_ptr(arg);
23989 arg_conv.is_owned = ptr_is_owned(arg);
23990 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23991 arg_conv.is_owned = false;
23992 int64_t ret_conv = ChannelConfig_clone_ptr(&arg_conv);
23996 uint64_t __attribute__((export_name("TS_ChannelConfig_clone"))) TS_ChannelConfig_clone(uint64_t orig) {
23997 LDKChannelConfig orig_conv;
23998 orig_conv.inner = untag_ptr(orig);
23999 orig_conv.is_owned = ptr_is_owned(orig);
24000 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24001 orig_conv.is_owned = false;
24002 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
24003 uint64_t ret_ref = 0;
24004 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24005 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24009 jboolean __attribute__((export_name("TS_ChannelConfig_eq"))) TS_ChannelConfig_eq(uint64_t a, uint64_t b) {
24010 LDKChannelConfig a_conv;
24011 a_conv.inner = untag_ptr(a);
24012 a_conv.is_owned = ptr_is_owned(a);
24013 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24014 a_conv.is_owned = false;
24015 LDKChannelConfig b_conv;
24016 b_conv.inner = untag_ptr(b);
24017 b_conv.is_owned = ptr_is_owned(b);
24018 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24019 b_conv.is_owned = false;
24020 jboolean ret_conv = ChannelConfig_eq(&a_conv, &b_conv);
24024 uint64_t __attribute__((export_name("TS_ChannelConfig_default"))) TS_ChannelConfig_default() {
24025 LDKChannelConfig ret_var = ChannelConfig_default();
24026 uint64_t ret_ref = 0;
24027 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24028 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24032 int8_tArray __attribute__((export_name("TS_ChannelConfig_write"))) TS_ChannelConfig_write(uint64_t obj) {
24033 LDKChannelConfig obj_conv;
24034 obj_conv.inner = untag_ptr(obj);
24035 obj_conv.is_owned = ptr_is_owned(obj);
24036 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
24037 obj_conv.is_owned = false;
24038 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
24039 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24040 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24041 CVec_u8Z_free(ret_var);
24045 uint64_t __attribute__((export_name("TS_ChannelConfig_read"))) TS_ChannelConfig_read(int8_tArray ser) {
24046 LDKu8slice ser_ref;
24047 ser_ref.datalen = ser->arr_len;
24048 ser_ref.data = ser->elems;
24049 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
24050 *ret_conv = ChannelConfig_read(ser_ref);
24052 return tag_ptr(ret_conv, true);
24055 void __attribute__((export_name("TS_UserConfig_free"))) TS_UserConfig_free(uint64_t this_obj) {
24056 LDKUserConfig this_obj_conv;
24057 this_obj_conv.inner = untag_ptr(this_obj);
24058 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24060 UserConfig_free(this_obj_conv);
24063 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_config"))) TS_UserConfig_get_channel_handshake_config(uint64_t this_ptr) {
24064 LDKUserConfig this_ptr_conv;
24065 this_ptr_conv.inner = untag_ptr(this_ptr);
24066 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24068 this_ptr_conv.is_owned = false;
24069 LDKChannelHandshakeConfig ret_var = UserConfig_get_channel_handshake_config(&this_ptr_conv);
24070 uint64_t ret_ref = 0;
24071 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24072 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24076 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_config"))) TS_UserConfig_set_channel_handshake_config(uint64_t this_ptr, uint64_t val) {
24077 LDKUserConfig this_ptr_conv;
24078 this_ptr_conv.inner = untag_ptr(this_ptr);
24079 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24080 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24081 this_ptr_conv.is_owned = false;
24082 LDKChannelHandshakeConfig val_conv;
24083 val_conv.inner = untag_ptr(val);
24084 val_conv.is_owned = ptr_is_owned(val);
24085 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24086 val_conv = ChannelHandshakeConfig_clone(&val_conv);
24087 UserConfig_set_channel_handshake_config(&this_ptr_conv, val_conv);
24090 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_limits"))) TS_UserConfig_get_channel_handshake_limits(uint64_t this_ptr) {
24091 LDKUserConfig this_ptr_conv;
24092 this_ptr_conv.inner = untag_ptr(this_ptr);
24093 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24095 this_ptr_conv.is_owned = false;
24096 LDKChannelHandshakeLimits ret_var = UserConfig_get_channel_handshake_limits(&this_ptr_conv);
24097 uint64_t ret_ref = 0;
24098 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24099 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24103 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_limits"))) TS_UserConfig_set_channel_handshake_limits(uint64_t this_ptr, uint64_t val) {
24104 LDKUserConfig this_ptr_conv;
24105 this_ptr_conv.inner = untag_ptr(this_ptr);
24106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24108 this_ptr_conv.is_owned = false;
24109 LDKChannelHandshakeLimits val_conv;
24110 val_conv.inner = untag_ptr(val);
24111 val_conv.is_owned = ptr_is_owned(val);
24112 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24113 val_conv = ChannelHandshakeLimits_clone(&val_conv);
24114 UserConfig_set_channel_handshake_limits(&this_ptr_conv, val_conv);
24117 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_config"))) TS_UserConfig_get_channel_config(uint64_t this_ptr) {
24118 LDKUserConfig this_ptr_conv;
24119 this_ptr_conv.inner = untag_ptr(this_ptr);
24120 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24122 this_ptr_conv.is_owned = false;
24123 LDKChannelConfig ret_var = UserConfig_get_channel_config(&this_ptr_conv);
24124 uint64_t ret_ref = 0;
24125 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24126 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24130 void __attribute__((export_name("TS_UserConfig_set_channel_config"))) TS_UserConfig_set_channel_config(uint64_t this_ptr, uint64_t val) {
24131 LDKUserConfig this_ptr_conv;
24132 this_ptr_conv.inner = untag_ptr(this_ptr);
24133 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24134 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24135 this_ptr_conv.is_owned = false;
24136 LDKChannelConfig val_conv;
24137 val_conv.inner = untag_ptr(val);
24138 val_conv.is_owned = ptr_is_owned(val);
24139 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24140 val_conv = ChannelConfig_clone(&val_conv);
24141 UserConfig_set_channel_config(&this_ptr_conv, val_conv);
24144 jboolean __attribute__((export_name("TS_UserConfig_get_accept_forwards_to_priv_channels"))) TS_UserConfig_get_accept_forwards_to_priv_channels(uint64_t this_ptr) {
24145 LDKUserConfig this_ptr_conv;
24146 this_ptr_conv.inner = untag_ptr(this_ptr);
24147 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24149 this_ptr_conv.is_owned = false;
24150 jboolean ret_conv = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
24154 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) {
24155 LDKUserConfig this_ptr_conv;
24156 this_ptr_conv.inner = untag_ptr(this_ptr);
24157 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24158 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24159 this_ptr_conv.is_owned = false;
24160 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
24163 jboolean __attribute__((export_name("TS_UserConfig_get_accept_inbound_channels"))) TS_UserConfig_get_accept_inbound_channels(uint64_t this_ptr) {
24164 LDKUserConfig this_ptr_conv;
24165 this_ptr_conv.inner = untag_ptr(this_ptr);
24166 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24168 this_ptr_conv.is_owned = false;
24169 jboolean ret_conv = UserConfig_get_accept_inbound_channels(&this_ptr_conv);
24173 void __attribute__((export_name("TS_UserConfig_set_accept_inbound_channels"))) TS_UserConfig_set_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
24174 LDKUserConfig this_ptr_conv;
24175 this_ptr_conv.inner = untag_ptr(this_ptr);
24176 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24177 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24178 this_ptr_conv.is_owned = false;
24179 UserConfig_set_accept_inbound_channels(&this_ptr_conv, val);
24182 jboolean __attribute__((export_name("TS_UserConfig_get_manually_accept_inbound_channels"))) TS_UserConfig_get_manually_accept_inbound_channels(uint64_t this_ptr) {
24183 LDKUserConfig this_ptr_conv;
24184 this_ptr_conv.inner = untag_ptr(this_ptr);
24185 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24187 this_ptr_conv.is_owned = false;
24188 jboolean ret_conv = UserConfig_get_manually_accept_inbound_channels(&this_ptr_conv);
24192 void __attribute__((export_name("TS_UserConfig_set_manually_accept_inbound_channels"))) TS_UserConfig_set_manually_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
24193 LDKUserConfig this_ptr_conv;
24194 this_ptr_conv.inner = untag_ptr(this_ptr);
24195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24197 this_ptr_conv.is_owned = false;
24198 UserConfig_set_manually_accept_inbound_channels(&this_ptr_conv, val);
24201 jboolean __attribute__((export_name("TS_UserConfig_get_accept_intercept_htlcs"))) TS_UserConfig_get_accept_intercept_htlcs(uint64_t this_ptr) {
24202 LDKUserConfig this_ptr_conv;
24203 this_ptr_conv.inner = untag_ptr(this_ptr);
24204 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24206 this_ptr_conv.is_owned = false;
24207 jboolean ret_conv = UserConfig_get_accept_intercept_htlcs(&this_ptr_conv);
24211 void __attribute__((export_name("TS_UserConfig_set_accept_intercept_htlcs"))) TS_UserConfig_set_accept_intercept_htlcs(uint64_t this_ptr, jboolean val) {
24212 LDKUserConfig this_ptr_conv;
24213 this_ptr_conv.inner = untag_ptr(this_ptr);
24214 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24215 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24216 this_ptr_conv.is_owned = false;
24217 UserConfig_set_accept_intercept_htlcs(&this_ptr_conv, val);
24220 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) {
24221 LDKChannelHandshakeConfig channel_handshake_config_arg_conv;
24222 channel_handshake_config_arg_conv.inner = untag_ptr(channel_handshake_config_arg);
24223 channel_handshake_config_arg_conv.is_owned = ptr_is_owned(channel_handshake_config_arg);
24224 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_config_arg_conv);
24225 channel_handshake_config_arg_conv = ChannelHandshakeConfig_clone(&channel_handshake_config_arg_conv);
24226 LDKChannelHandshakeLimits channel_handshake_limits_arg_conv;
24227 channel_handshake_limits_arg_conv.inner = untag_ptr(channel_handshake_limits_arg);
24228 channel_handshake_limits_arg_conv.is_owned = ptr_is_owned(channel_handshake_limits_arg);
24229 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_limits_arg_conv);
24230 channel_handshake_limits_arg_conv = ChannelHandshakeLimits_clone(&channel_handshake_limits_arg_conv);
24231 LDKChannelConfig channel_config_arg_conv;
24232 channel_config_arg_conv.inner = untag_ptr(channel_config_arg);
24233 channel_config_arg_conv.is_owned = ptr_is_owned(channel_config_arg);
24234 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_config_arg_conv);
24235 channel_config_arg_conv = ChannelConfig_clone(&channel_config_arg_conv);
24236 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);
24237 uint64_t ret_ref = 0;
24238 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24239 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24243 static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
24244 LDKUserConfig ret_var = UserConfig_clone(arg);
24245 uint64_t ret_ref = 0;
24246 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24247 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24250 int64_t __attribute__((export_name("TS_UserConfig_clone_ptr"))) TS_UserConfig_clone_ptr(uint64_t arg) {
24251 LDKUserConfig arg_conv;
24252 arg_conv.inner = untag_ptr(arg);
24253 arg_conv.is_owned = ptr_is_owned(arg);
24254 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24255 arg_conv.is_owned = false;
24256 int64_t ret_conv = UserConfig_clone_ptr(&arg_conv);
24260 uint64_t __attribute__((export_name("TS_UserConfig_clone"))) TS_UserConfig_clone(uint64_t orig) {
24261 LDKUserConfig orig_conv;
24262 orig_conv.inner = untag_ptr(orig);
24263 orig_conv.is_owned = ptr_is_owned(orig);
24264 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24265 orig_conv.is_owned = false;
24266 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
24267 uint64_t ret_ref = 0;
24268 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24269 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24273 uint64_t __attribute__((export_name("TS_UserConfig_default"))) TS_UserConfig_default() {
24274 LDKUserConfig ret_var = UserConfig_default();
24275 uint64_t ret_ref = 0;
24276 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24277 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24281 void __attribute__((export_name("TS_BestBlock_free"))) TS_BestBlock_free(uint64_t this_obj) {
24282 LDKBestBlock this_obj_conv;
24283 this_obj_conv.inner = untag_ptr(this_obj);
24284 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24285 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24286 BestBlock_free(this_obj_conv);
24289 static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
24290 LDKBestBlock ret_var = BestBlock_clone(arg);
24291 uint64_t ret_ref = 0;
24292 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24293 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24296 int64_t __attribute__((export_name("TS_BestBlock_clone_ptr"))) TS_BestBlock_clone_ptr(uint64_t arg) {
24297 LDKBestBlock arg_conv;
24298 arg_conv.inner = untag_ptr(arg);
24299 arg_conv.is_owned = ptr_is_owned(arg);
24300 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24301 arg_conv.is_owned = false;
24302 int64_t ret_conv = BestBlock_clone_ptr(&arg_conv);
24306 uint64_t __attribute__((export_name("TS_BestBlock_clone"))) TS_BestBlock_clone(uint64_t orig) {
24307 LDKBestBlock orig_conv;
24308 orig_conv.inner = untag_ptr(orig);
24309 orig_conv.is_owned = ptr_is_owned(orig);
24310 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24311 orig_conv.is_owned = false;
24312 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
24313 uint64_t ret_ref = 0;
24314 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24315 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24319 jboolean __attribute__((export_name("TS_BestBlock_eq"))) TS_BestBlock_eq(uint64_t a, uint64_t b) {
24320 LDKBestBlock a_conv;
24321 a_conv.inner = untag_ptr(a);
24322 a_conv.is_owned = ptr_is_owned(a);
24323 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24324 a_conv.is_owned = false;
24325 LDKBestBlock b_conv;
24326 b_conv.inner = untag_ptr(b);
24327 b_conv.is_owned = ptr_is_owned(b);
24328 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24329 b_conv.is_owned = false;
24330 jboolean ret_conv = BestBlock_eq(&a_conv, &b_conv);
24334 uint64_t __attribute__((export_name("TS_BestBlock_from_network"))) TS_BestBlock_from_network(uint32_t network) {
24335 LDKNetwork network_conv = LDKNetwork_from_js(network);
24336 LDKBestBlock ret_var = BestBlock_from_network(network_conv);
24337 uint64_t ret_ref = 0;
24338 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24339 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24343 uint64_t __attribute__((export_name("TS_BestBlock_new"))) TS_BestBlock_new(int8_tArray block_hash, int32_t height) {
24344 LDKThirtyTwoBytes block_hash_ref;
24345 CHECK(block_hash->arr_len == 32);
24346 memcpy(block_hash_ref.data, block_hash->elems, 32); FREE(block_hash);
24347 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
24348 uint64_t ret_ref = 0;
24349 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24350 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24354 int8_tArray __attribute__((export_name("TS_BestBlock_block_hash"))) TS_BestBlock_block_hash(uint64_t this_arg) {
24355 LDKBestBlock this_arg_conv;
24356 this_arg_conv.inner = untag_ptr(this_arg);
24357 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24359 this_arg_conv.is_owned = false;
24360 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24361 memcpy(ret_arr->elems, BestBlock_block_hash(&this_arg_conv).data, 32);
24365 int32_t __attribute__((export_name("TS_BestBlock_height"))) TS_BestBlock_height(uint64_t this_arg) {
24366 LDKBestBlock this_arg_conv;
24367 this_arg_conv.inner = untag_ptr(this_arg);
24368 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24369 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24370 this_arg_conv.is_owned = false;
24371 int32_t ret_conv = BestBlock_height(&this_arg_conv);
24375 void __attribute__((export_name("TS_Listen_free"))) TS_Listen_free(uint64_t this_ptr) {
24376 if (!ptr_is_owned(this_ptr)) return;
24377 void* this_ptr_ptr = untag_ptr(this_ptr);
24378 CHECK_ACCESS(this_ptr_ptr);
24379 LDKListen this_ptr_conv = *(LDKListen*)(this_ptr_ptr);
24380 FREE(untag_ptr(this_ptr));
24381 Listen_free(this_ptr_conv);
24384 void __attribute__((export_name("TS_Confirm_free"))) TS_Confirm_free(uint64_t this_ptr) {
24385 if (!ptr_is_owned(this_ptr)) return;
24386 void* this_ptr_ptr = untag_ptr(this_ptr);
24387 CHECK_ACCESS(this_ptr_ptr);
24388 LDKConfirm this_ptr_conv = *(LDKConfirm*)(this_ptr_ptr);
24389 FREE(untag_ptr(this_ptr));
24390 Confirm_free(this_ptr_conv);
24393 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_clone"))) TS_ChannelMonitorUpdateStatus_clone(uint64_t orig) {
24394 LDKChannelMonitorUpdateStatus* orig_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(orig);
24395 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_clone(orig_conv));
24399 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_completed"))) TS_ChannelMonitorUpdateStatus_completed() {
24400 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_completed());
24404 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_in_progress"))) TS_ChannelMonitorUpdateStatus_in_progress() {
24405 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_in_progress());
24409 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_permanent_failure"))) TS_ChannelMonitorUpdateStatus_permanent_failure() {
24410 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_permanent_failure());
24414 jboolean __attribute__((export_name("TS_ChannelMonitorUpdateStatus_eq"))) TS_ChannelMonitorUpdateStatus_eq(uint64_t a, uint64_t b) {
24415 LDKChannelMonitorUpdateStatus* a_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(a);
24416 LDKChannelMonitorUpdateStatus* b_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(b);
24417 jboolean ret_conv = ChannelMonitorUpdateStatus_eq(a_conv, b_conv);
24421 void __attribute__((export_name("TS_Watch_free"))) TS_Watch_free(uint64_t this_ptr) {
24422 if (!ptr_is_owned(this_ptr)) return;
24423 void* this_ptr_ptr = untag_ptr(this_ptr);
24424 CHECK_ACCESS(this_ptr_ptr);
24425 LDKWatch this_ptr_conv = *(LDKWatch*)(this_ptr_ptr);
24426 FREE(untag_ptr(this_ptr));
24427 Watch_free(this_ptr_conv);
24430 void __attribute__((export_name("TS_Filter_free"))) TS_Filter_free(uint64_t this_ptr) {
24431 if (!ptr_is_owned(this_ptr)) return;
24432 void* this_ptr_ptr = untag_ptr(this_ptr);
24433 CHECK_ACCESS(this_ptr_ptr);
24434 LDKFilter this_ptr_conv = *(LDKFilter*)(this_ptr_ptr);
24435 FREE(untag_ptr(this_ptr));
24436 Filter_free(this_ptr_conv);
24439 void __attribute__((export_name("TS_WatchedOutput_free"))) TS_WatchedOutput_free(uint64_t this_obj) {
24440 LDKWatchedOutput this_obj_conv;
24441 this_obj_conv.inner = untag_ptr(this_obj);
24442 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24444 WatchedOutput_free(this_obj_conv);
24447 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_block_hash"))) TS_WatchedOutput_get_block_hash(uint64_t this_ptr) {
24448 LDKWatchedOutput this_ptr_conv;
24449 this_ptr_conv.inner = untag_ptr(this_ptr);
24450 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24452 this_ptr_conv.is_owned = false;
24453 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24454 memcpy(ret_arr->elems, WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
24458 void __attribute__((export_name("TS_WatchedOutput_set_block_hash"))) TS_WatchedOutput_set_block_hash(uint64_t this_ptr, int8_tArray val) {
24459 LDKWatchedOutput this_ptr_conv;
24460 this_ptr_conv.inner = untag_ptr(this_ptr);
24461 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24463 this_ptr_conv.is_owned = false;
24464 LDKThirtyTwoBytes val_ref;
24465 CHECK(val->arr_len == 32);
24466 memcpy(val_ref.data, val->elems, 32); FREE(val);
24467 WatchedOutput_set_block_hash(&this_ptr_conv, val_ref);
24470 uint64_t __attribute__((export_name("TS_WatchedOutput_get_outpoint"))) TS_WatchedOutput_get_outpoint(uint64_t this_ptr) {
24471 LDKWatchedOutput this_ptr_conv;
24472 this_ptr_conv.inner = untag_ptr(this_ptr);
24473 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24474 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24475 this_ptr_conv.is_owned = false;
24476 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
24477 uint64_t ret_ref = 0;
24478 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24479 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24483 void __attribute__((export_name("TS_WatchedOutput_set_outpoint"))) TS_WatchedOutput_set_outpoint(uint64_t this_ptr, uint64_t val) {
24484 LDKWatchedOutput this_ptr_conv;
24485 this_ptr_conv.inner = untag_ptr(this_ptr);
24486 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24488 this_ptr_conv.is_owned = false;
24489 LDKOutPoint val_conv;
24490 val_conv.inner = untag_ptr(val);
24491 val_conv.is_owned = ptr_is_owned(val);
24492 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24493 val_conv = OutPoint_clone(&val_conv);
24494 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
24497 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_script_pubkey"))) TS_WatchedOutput_get_script_pubkey(uint64_t this_ptr) {
24498 LDKWatchedOutput this_ptr_conv;
24499 this_ptr_conv.inner = untag_ptr(this_ptr);
24500 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24501 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24502 this_ptr_conv.is_owned = false;
24503 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
24504 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24505 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24509 void __attribute__((export_name("TS_WatchedOutput_set_script_pubkey"))) TS_WatchedOutput_set_script_pubkey(uint64_t this_ptr, int8_tArray val) {
24510 LDKWatchedOutput this_ptr_conv;
24511 this_ptr_conv.inner = untag_ptr(this_ptr);
24512 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24514 this_ptr_conv.is_owned = false;
24515 LDKCVec_u8Z val_ref;
24516 val_ref.datalen = val->arr_len;
24517 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
24518 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
24519 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
24522 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) {
24523 LDKThirtyTwoBytes block_hash_arg_ref;
24524 CHECK(block_hash_arg->arr_len == 32);
24525 memcpy(block_hash_arg_ref.data, block_hash_arg->elems, 32); FREE(block_hash_arg);
24526 LDKOutPoint outpoint_arg_conv;
24527 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
24528 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
24529 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
24530 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
24531 LDKCVec_u8Z script_pubkey_arg_ref;
24532 script_pubkey_arg_ref.datalen = script_pubkey_arg->arr_len;
24533 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
24534 memcpy(script_pubkey_arg_ref.data, script_pubkey_arg->elems, script_pubkey_arg_ref.datalen); FREE(script_pubkey_arg);
24535 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_ref, outpoint_arg_conv, script_pubkey_arg_ref);
24536 uint64_t ret_ref = 0;
24537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24542 static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
24543 LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
24544 uint64_t ret_ref = 0;
24545 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24546 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24549 int64_t __attribute__((export_name("TS_WatchedOutput_clone_ptr"))) TS_WatchedOutput_clone_ptr(uint64_t arg) {
24550 LDKWatchedOutput arg_conv;
24551 arg_conv.inner = untag_ptr(arg);
24552 arg_conv.is_owned = ptr_is_owned(arg);
24553 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24554 arg_conv.is_owned = false;
24555 int64_t ret_conv = WatchedOutput_clone_ptr(&arg_conv);
24559 uint64_t __attribute__((export_name("TS_WatchedOutput_clone"))) TS_WatchedOutput_clone(uint64_t orig) {
24560 LDKWatchedOutput orig_conv;
24561 orig_conv.inner = untag_ptr(orig);
24562 orig_conv.is_owned = ptr_is_owned(orig);
24563 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24564 orig_conv.is_owned = false;
24565 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
24566 uint64_t ret_ref = 0;
24567 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24568 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24572 jboolean __attribute__((export_name("TS_WatchedOutput_eq"))) TS_WatchedOutput_eq(uint64_t a, uint64_t b) {
24573 LDKWatchedOutput a_conv;
24574 a_conv.inner = untag_ptr(a);
24575 a_conv.is_owned = ptr_is_owned(a);
24576 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24577 a_conv.is_owned = false;
24578 LDKWatchedOutput b_conv;
24579 b_conv.inner = untag_ptr(b);
24580 b_conv.is_owned = ptr_is_owned(b);
24581 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24582 b_conv.is_owned = false;
24583 jboolean ret_conv = WatchedOutput_eq(&a_conv, &b_conv);
24587 int64_t __attribute__((export_name("TS_WatchedOutput_hash"))) TS_WatchedOutput_hash(uint64_t o) {
24588 LDKWatchedOutput o_conv;
24589 o_conv.inner = untag_ptr(o);
24590 o_conv.is_owned = ptr_is_owned(o);
24591 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24592 o_conv.is_owned = false;
24593 int64_t ret_conv = WatchedOutput_hash(&o_conv);
24597 void __attribute__((export_name("TS_BroadcasterInterface_free"))) TS_BroadcasterInterface_free(uint64_t this_ptr) {
24598 if (!ptr_is_owned(this_ptr)) return;
24599 void* this_ptr_ptr = untag_ptr(this_ptr);
24600 CHECK_ACCESS(this_ptr_ptr);
24601 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(this_ptr_ptr);
24602 FREE(untag_ptr(this_ptr));
24603 BroadcasterInterface_free(this_ptr_conv);
24606 uint32_t __attribute__((export_name("TS_ConfirmationTarget_clone"))) TS_ConfirmationTarget_clone(uint64_t orig) {
24607 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)untag_ptr(orig);
24608 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_clone(orig_conv));
24612 uint32_t __attribute__((export_name("TS_ConfirmationTarget_background"))) TS_ConfirmationTarget_background() {
24613 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_background());
24617 uint32_t __attribute__((export_name("TS_ConfirmationTarget_normal"))) TS_ConfirmationTarget_normal() {
24618 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_normal());
24622 uint32_t __attribute__((export_name("TS_ConfirmationTarget_high_priority"))) TS_ConfirmationTarget_high_priority() {
24623 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_high_priority());
24627 int64_t __attribute__((export_name("TS_ConfirmationTarget_hash"))) TS_ConfirmationTarget_hash(uint64_t o) {
24628 LDKConfirmationTarget* o_conv = (LDKConfirmationTarget*)untag_ptr(o);
24629 int64_t ret_conv = ConfirmationTarget_hash(o_conv);
24633 jboolean __attribute__((export_name("TS_ConfirmationTarget_eq"))) TS_ConfirmationTarget_eq(uint64_t a, uint64_t b) {
24634 LDKConfirmationTarget* a_conv = (LDKConfirmationTarget*)untag_ptr(a);
24635 LDKConfirmationTarget* b_conv = (LDKConfirmationTarget*)untag_ptr(b);
24636 jboolean ret_conv = ConfirmationTarget_eq(a_conv, b_conv);
24640 void __attribute__((export_name("TS_FeeEstimator_free"))) TS_FeeEstimator_free(uint64_t this_ptr) {
24641 if (!ptr_is_owned(this_ptr)) return;
24642 void* this_ptr_ptr = untag_ptr(this_ptr);
24643 CHECK_ACCESS(this_ptr_ptr);
24644 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(this_ptr_ptr);
24645 FREE(untag_ptr(this_ptr));
24646 FeeEstimator_free(this_ptr_conv);
24649 void __attribute__((export_name("TS_MonitorUpdateId_free"))) TS_MonitorUpdateId_free(uint64_t this_obj) {
24650 LDKMonitorUpdateId this_obj_conv;
24651 this_obj_conv.inner = untag_ptr(this_obj);
24652 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24654 MonitorUpdateId_free(this_obj_conv);
24657 static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
24658 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
24659 uint64_t ret_ref = 0;
24660 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24661 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24664 int64_t __attribute__((export_name("TS_MonitorUpdateId_clone_ptr"))) TS_MonitorUpdateId_clone_ptr(uint64_t arg) {
24665 LDKMonitorUpdateId arg_conv;
24666 arg_conv.inner = untag_ptr(arg);
24667 arg_conv.is_owned = ptr_is_owned(arg);
24668 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24669 arg_conv.is_owned = false;
24670 int64_t ret_conv = MonitorUpdateId_clone_ptr(&arg_conv);
24674 uint64_t __attribute__((export_name("TS_MonitorUpdateId_clone"))) TS_MonitorUpdateId_clone(uint64_t orig) {
24675 LDKMonitorUpdateId orig_conv;
24676 orig_conv.inner = untag_ptr(orig);
24677 orig_conv.is_owned = ptr_is_owned(orig);
24678 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24679 orig_conv.is_owned = false;
24680 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
24681 uint64_t ret_ref = 0;
24682 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24683 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24687 int64_t __attribute__((export_name("TS_MonitorUpdateId_hash"))) TS_MonitorUpdateId_hash(uint64_t o) {
24688 LDKMonitorUpdateId o_conv;
24689 o_conv.inner = untag_ptr(o);
24690 o_conv.is_owned = ptr_is_owned(o);
24691 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24692 o_conv.is_owned = false;
24693 int64_t ret_conv = MonitorUpdateId_hash(&o_conv);
24697 jboolean __attribute__((export_name("TS_MonitorUpdateId_eq"))) TS_MonitorUpdateId_eq(uint64_t a, uint64_t b) {
24698 LDKMonitorUpdateId a_conv;
24699 a_conv.inner = untag_ptr(a);
24700 a_conv.is_owned = ptr_is_owned(a);
24701 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24702 a_conv.is_owned = false;
24703 LDKMonitorUpdateId b_conv;
24704 b_conv.inner = untag_ptr(b);
24705 b_conv.is_owned = ptr_is_owned(b);
24706 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24707 b_conv.is_owned = false;
24708 jboolean ret_conv = MonitorUpdateId_eq(&a_conv, &b_conv);
24712 void __attribute__((export_name("TS_Persist_free"))) TS_Persist_free(uint64_t this_ptr) {
24713 if (!ptr_is_owned(this_ptr)) return;
24714 void* this_ptr_ptr = untag_ptr(this_ptr);
24715 CHECK_ACCESS(this_ptr_ptr);
24716 LDKPersist this_ptr_conv = *(LDKPersist*)(this_ptr_ptr);
24717 FREE(untag_ptr(this_ptr));
24718 Persist_free(this_ptr_conv);
24721 void __attribute__((export_name("TS_LockedChannelMonitor_free"))) TS_LockedChannelMonitor_free(uint64_t this_obj) {
24722 LDKLockedChannelMonitor this_obj_conv;
24723 this_obj_conv.inner = untag_ptr(this_obj);
24724 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24725 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24726 LockedChannelMonitor_free(this_obj_conv);
24729 void __attribute__((export_name("TS_ChainMonitor_free"))) TS_ChainMonitor_free(uint64_t this_obj) {
24730 LDKChainMonitor this_obj_conv;
24731 this_obj_conv.inner = untag_ptr(this_obj);
24732 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24734 ChainMonitor_free(this_obj_conv);
24737 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) {
24738 void* chain_source_ptr = untag_ptr(chain_source);
24739 CHECK_ACCESS(chain_source_ptr);
24740 LDKCOption_FilterZ chain_source_conv = *(LDKCOption_FilterZ*)(chain_source_ptr);
24741 // WARNING: we may need a move here but no clone is available for LDKCOption_FilterZ
24742 if (chain_source_conv.tag == LDKCOption_FilterZ_Some) {
24743 // Manually implement clone for Java trait instances
24744 if (chain_source_conv.some.free == LDKFilter_JCalls_free) {
24745 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24746 LDKFilter_JCalls_cloned(&chain_source_conv.some);
24749 void* broadcaster_ptr = untag_ptr(broadcaster);
24750 CHECK_ACCESS(broadcaster_ptr);
24751 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24752 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24753 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24754 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24756 void* logger_ptr = untag_ptr(logger);
24757 CHECK_ACCESS(logger_ptr);
24758 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24759 if (logger_conv.free == LDKLogger_JCalls_free) {
24760 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24761 LDKLogger_JCalls_cloned(&logger_conv);
24763 void* feeest_ptr = untag_ptr(feeest);
24764 CHECK_ACCESS(feeest_ptr);
24765 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(feeest_ptr);
24766 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
24767 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24768 LDKFeeEstimator_JCalls_cloned(&feeest_conv);
24770 void* persister_ptr = untag_ptr(persister);
24771 CHECK_ACCESS(persister_ptr);
24772 LDKPersist persister_conv = *(LDKPersist*)(persister_ptr);
24773 if (persister_conv.free == LDKPersist_JCalls_free) {
24774 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24775 LDKPersist_JCalls_cloned(&persister_conv);
24777 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
24778 uint64_t ret_ref = 0;
24779 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24780 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24784 uint64_tArray __attribute__((export_name("TS_ChainMonitor_get_claimable_balances"))) TS_ChainMonitor_get_claimable_balances(uint64_t this_arg, uint64_tArray ignored_channels) {
24785 LDKChainMonitor this_arg_conv;
24786 this_arg_conv.inner = untag_ptr(this_arg);
24787 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24789 this_arg_conv.is_owned = false;
24790 LDKCVec_ChannelDetailsZ ignored_channels_constr;
24791 ignored_channels_constr.datalen = ignored_channels->arr_len;
24792 if (ignored_channels_constr.datalen > 0)
24793 ignored_channels_constr.data = MALLOC(ignored_channels_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
24795 ignored_channels_constr.data = NULL;
24796 uint64_t* ignored_channels_vals = ignored_channels->elems;
24797 for (size_t q = 0; q < ignored_channels_constr.datalen; q++) {
24798 uint64_t ignored_channels_conv_16 = ignored_channels_vals[q];
24799 LDKChannelDetails ignored_channels_conv_16_conv;
24800 ignored_channels_conv_16_conv.inner = untag_ptr(ignored_channels_conv_16);
24801 ignored_channels_conv_16_conv.is_owned = ptr_is_owned(ignored_channels_conv_16);
24802 CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
24803 ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
24804 ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
24806 FREE(ignored_channels);
24807 LDKCVec_BalanceZ ret_var = ChainMonitor_get_claimable_balances(&this_arg_conv, ignored_channels_constr);
24808 uint64_tArray ret_arr = NULL;
24809 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24810 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24811 for (size_t j = 0; j < ret_var.datalen; j++) {
24812 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
24813 *ret_conv_9_copy = ret_var.data[j];
24814 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
24815 ret_arr_ptr[j] = ret_conv_9_ref;
24818 FREE(ret_var.data);
24822 uint64_t __attribute__((export_name("TS_ChainMonitor_get_monitor"))) TS_ChainMonitor_get_monitor(uint64_t this_arg, uint64_t funding_txo) {
24823 LDKChainMonitor this_arg_conv;
24824 this_arg_conv.inner = untag_ptr(this_arg);
24825 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24827 this_arg_conv.is_owned = false;
24828 LDKOutPoint funding_txo_conv;
24829 funding_txo_conv.inner = untag_ptr(funding_txo);
24830 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24831 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24832 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24833 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
24834 *ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
24835 return tag_ptr(ret_conv, true);
24838 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_monitors"))) TS_ChainMonitor_list_monitors(uint64_t this_arg) {
24839 LDKChainMonitor this_arg_conv;
24840 this_arg_conv.inner = untag_ptr(this_arg);
24841 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24843 this_arg_conv.is_owned = false;
24844 LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
24845 uint64_tArray ret_arr = NULL;
24846 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24847 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24848 for (size_t k = 0; k < ret_var.datalen; k++) {
24849 LDKOutPoint ret_conv_10_var = ret_var.data[k];
24850 uint64_t ret_conv_10_ref = 0;
24851 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
24852 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
24853 ret_arr_ptr[k] = ret_conv_10_ref;
24856 FREE(ret_var.data);
24860 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_pending_monitor_updates"))) TS_ChainMonitor_list_pending_monitor_updates(uint64_t this_arg) {
24861 LDKChainMonitor this_arg_conv;
24862 this_arg_conv.inner = untag_ptr(this_arg);
24863 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24865 this_arg_conv.is_owned = false;
24866 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret_var = ChainMonitor_list_pending_monitor_updates(&this_arg_conv);
24867 uint64_tArray ret_arr = NULL;
24868 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24869 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24870 for (size_t p = 0; p < ret_var.datalen; p++) {
24871 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv_41_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
24872 *ret_conv_41_conv = ret_var.data[p];
24873 ret_arr_ptr[p] = tag_ptr(ret_conv_41_conv, true);
24876 FREE(ret_var.data);
24880 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) {
24881 LDKChainMonitor this_arg_conv;
24882 this_arg_conv.inner = untag_ptr(this_arg);
24883 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24885 this_arg_conv.is_owned = false;
24886 LDKOutPoint funding_txo_conv;
24887 funding_txo_conv.inner = untag_ptr(funding_txo);
24888 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24889 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24890 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24891 LDKMonitorUpdateId completed_update_id_conv;
24892 completed_update_id_conv.inner = untag_ptr(completed_update_id);
24893 completed_update_id_conv.is_owned = ptr_is_owned(completed_update_id);
24894 CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
24895 completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
24896 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
24897 *ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
24898 return tag_ptr(ret_conv, true);
24901 uint64_t __attribute__((export_name("TS_ChainMonitor_get_update_future"))) TS_ChainMonitor_get_update_future(uint64_t this_arg) {
24902 LDKChainMonitor this_arg_conv;
24903 this_arg_conv.inner = untag_ptr(this_arg);
24904 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24906 this_arg_conv.is_owned = false;
24907 LDKFuture ret_var = ChainMonitor_get_update_future(&this_arg_conv);
24908 uint64_t ret_ref = 0;
24909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24914 void __attribute__((export_name("TS_ChainMonitor_rebroadcast_pending_claims"))) TS_ChainMonitor_rebroadcast_pending_claims(uint64_t this_arg) {
24915 LDKChainMonitor this_arg_conv;
24916 this_arg_conv.inner = untag_ptr(this_arg);
24917 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24919 this_arg_conv.is_owned = false;
24920 ChainMonitor_rebroadcast_pending_claims(&this_arg_conv);
24923 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Listen"))) TS_ChainMonitor_as_Listen(uint64_t this_arg) {
24924 LDKChainMonitor this_arg_conv;
24925 this_arg_conv.inner = untag_ptr(this_arg);
24926 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24928 this_arg_conv.is_owned = false;
24929 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
24930 *ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
24931 return tag_ptr(ret_ret, true);
24934 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Confirm"))) TS_ChainMonitor_as_Confirm(uint64_t this_arg) {
24935 LDKChainMonitor this_arg_conv;
24936 this_arg_conv.inner = untag_ptr(this_arg);
24937 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24938 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24939 this_arg_conv.is_owned = false;
24940 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
24941 *ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
24942 return tag_ptr(ret_ret, true);
24945 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Watch"))) TS_ChainMonitor_as_Watch(uint64_t this_arg) {
24946 LDKChainMonitor this_arg_conv;
24947 this_arg_conv.inner = untag_ptr(this_arg);
24948 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24950 this_arg_conv.is_owned = false;
24951 LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
24952 *ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
24953 return tag_ptr(ret_ret, true);
24956 uint64_t __attribute__((export_name("TS_ChainMonitor_as_EventsProvider"))) TS_ChainMonitor_as_EventsProvider(uint64_t this_arg) {
24957 LDKChainMonitor this_arg_conv;
24958 this_arg_conv.inner = untag_ptr(this_arg);
24959 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24961 this_arg_conv.is_owned = false;
24962 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
24963 *ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
24964 return tag_ptr(ret_ret, true);
24967 void __attribute__((export_name("TS_ChannelMonitorUpdate_free"))) TS_ChannelMonitorUpdate_free(uint64_t this_obj) {
24968 LDKChannelMonitorUpdate this_obj_conv;
24969 this_obj_conv.inner = untag_ptr(this_obj);
24970 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24972 ChannelMonitorUpdate_free(this_obj_conv);
24975 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_get_update_id"))) TS_ChannelMonitorUpdate_get_update_id(uint64_t this_ptr) {
24976 LDKChannelMonitorUpdate this_ptr_conv;
24977 this_ptr_conv.inner = untag_ptr(this_ptr);
24978 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24980 this_ptr_conv.is_owned = false;
24981 int64_t ret_conv = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
24985 void __attribute__((export_name("TS_ChannelMonitorUpdate_set_update_id"))) TS_ChannelMonitorUpdate_set_update_id(uint64_t this_ptr, int64_t val) {
24986 LDKChannelMonitorUpdate this_ptr_conv;
24987 this_ptr_conv.inner = untag_ptr(this_ptr);
24988 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24990 this_ptr_conv.is_owned = false;
24991 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
24994 static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
24995 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
24996 uint64_t ret_ref = 0;
24997 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24998 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25001 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone_ptr"))) TS_ChannelMonitorUpdate_clone_ptr(uint64_t arg) {
25002 LDKChannelMonitorUpdate arg_conv;
25003 arg_conv.inner = untag_ptr(arg);
25004 arg_conv.is_owned = ptr_is_owned(arg);
25005 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25006 arg_conv.is_owned = false;
25007 int64_t ret_conv = ChannelMonitorUpdate_clone_ptr(&arg_conv);
25011 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone"))) TS_ChannelMonitorUpdate_clone(uint64_t orig) {
25012 LDKChannelMonitorUpdate orig_conv;
25013 orig_conv.inner = untag_ptr(orig);
25014 orig_conv.is_owned = ptr_is_owned(orig);
25015 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25016 orig_conv.is_owned = false;
25017 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
25018 uint64_t ret_ref = 0;
25019 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25020 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25024 jboolean __attribute__((export_name("TS_ChannelMonitorUpdate_eq"))) TS_ChannelMonitorUpdate_eq(uint64_t a, uint64_t b) {
25025 LDKChannelMonitorUpdate a_conv;
25026 a_conv.inner = untag_ptr(a);
25027 a_conv.is_owned = ptr_is_owned(a);
25028 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25029 a_conv.is_owned = false;
25030 LDKChannelMonitorUpdate b_conv;
25031 b_conv.inner = untag_ptr(b);
25032 b_conv.is_owned = ptr_is_owned(b);
25033 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25034 b_conv.is_owned = false;
25035 jboolean ret_conv = ChannelMonitorUpdate_eq(&a_conv, &b_conv);
25039 int8_tArray __attribute__((export_name("TS_ChannelMonitorUpdate_write"))) TS_ChannelMonitorUpdate_write(uint64_t obj) {
25040 LDKChannelMonitorUpdate obj_conv;
25041 obj_conv.inner = untag_ptr(obj);
25042 obj_conv.is_owned = ptr_is_owned(obj);
25043 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25044 obj_conv.is_owned = false;
25045 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
25046 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25047 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25048 CVec_u8Z_free(ret_var);
25052 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_read"))) TS_ChannelMonitorUpdate_read(int8_tArray ser) {
25053 LDKu8slice ser_ref;
25054 ser_ref.datalen = ser->arr_len;
25055 ser_ref.data = ser->elems;
25056 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
25057 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
25059 return tag_ptr(ret_conv, true);
25062 void __attribute__((export_name("TS_MonitorEvent_free"))) TS_MonitorEvent_free(uint64_t this_ptr) {
25063 if (!ptr_is_owned(this_ptr)) return;
25064 void* this_ptr_ptr = untag_ptr(this_ptr);
25065 CHECK_ACCESS(this_ptr_ptr);
25066 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(this_ptr_ptr);
25067 FREE(untag_ptr(this_ptr));
25068 MonitorEvent_free(this_ptr_conv);
25071 static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
25072 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25073 *ret_copy = MonitorEvent_clone(arg);
25074 uint64_t ret_ref = tag_ptr(ret_copy, true);
25077 int64_t __attribute__((export_name("TS_MonitorEvent_clone_ptr"))) TS_MonitorEvent_clone_ptr(uint64_t arg) {
25078 LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)untag_ptr(arg);
25079 int64_t ret_conv = MonitorEvent_clone_ptr(arg_conv);
25083 uint64_t __attribute__((export_name("TS_MonitorEvent_clone"))) TS_MonitorEvent_clone(uint64_t orig) {
25084 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)untag_ptr(orig);
25085 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25086 *ret_copy = MonitorEvent_clone(orig_conv);
25087 uint64_t ret_ref = tag_ptr(ret_copy, true);
25091 uint64_t __attribute__((export_name("TS_MonitorEvent_htlcevent"))) TS_MonitorEvent_htlcevent(uint64_t a) {
25092 LDKHTLCUpdate a_conv;
25093 a_conv.inner = untag_ptr(a);
25094 a_conv.is_owned = ptr_is_owned(a);
25095 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25096 a_conv = HTLCUpdate_clone(&a_conv);
25097 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25098 *ret_copy = MonitorEvent_htlcevent(a_conv);
25099 uint64_t ret_ref = tag_ptr(ret_copy, true);
25103 uint64_t __attribute__((export_name("TS_MonitorEvent_commitment_tx_confirmed"))) TS_MonitorEvent_commitment_tx_confirmed(uint64_t a) {
25104 LDKOutPoint a_conv;
25105 a_conv.inner = untag_ptr(a);
25106 a_conv.is_owned = ptr_is_owned(a);
25107 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25108 a_conv = OutPoint_clone(&a_conv);
25109 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25110 *ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
25111 uint64_t ret_ref = tag_ptr(ret_copy, true);
25115 uint64_t __attribute__((export_name("TS_MonitorEvent_completed"))) TS_MonitorEvent_completed(uint64_t funding_txo, int64_t monitor_update_id) {
25116 LDKOutPoint funding_txo_conv;
25117 funding_txo_conv.inner = untag_ptr(funding_txo);
25118 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
25119 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
25120 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
25121 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25122 *ret_copy = MonitorEvent_completed(funding_txo_conv, monitor_update_id);
25123 uint64_t ret_ref = tag_ptr(ret_copy, true);
25127 uint64_t __attribute__((export_name("TS_MonitorEvent_update_failed"))) TS_MonitorEvent_update_failed(uint64_t a) {
25128 LDKOutPoint a_conv;
25129 a_conv.inner = untag_ptr(a);
25130 a_conv.is_owned = ptr_is_owned(a);
25131 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25132 a_conv = OutPoint_clone(&a_conv);
25133 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25134 *ret_copy = MonitorEvent_update_failed(a_conv);
25135 uint64_t ret_ref = tag_ptr(ret_copy, true);
25139 jboolean __attribute__((export_name("TS_MonitorEvent_eq"))) TS_MonitorEvent_eq(uint64_t a, uint64_t b) {
25140 LDKMonitorEvent* a_conv = (LDKMonitorEvent*)untag_ptr(a);
25141 LDKMonitorEvent* b_conv = (LDKMonitorEvent*)untag_ptr(b);
25142 jboolean ret_conv = MonitorEvent_eq(a_conv, b_conv);
25146 int8_tArray __attribute__((export_name("TS_MonitorEvent_write"))) TS_MonitorEvent_write(uint64_t obj) {
25147 LDKMonitorEvent* obj_conv = (LDKMonitorEvent*)untag_ptr(obj);
25148 LDKCVec_u8Z ret_var = MonitorEvent_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_MonitorEvent_read"))) TS_MonitorEvent_read(int8_tArray ser) {
25156 LDKu8slice ser_ref;
25157 ser_ref.datalen = ser->arr_len;
25158 ser_ref.data = ser->elems;
25159 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
25160 *ret_conv = MonitorEvent_read(ser_ref);
25162 return tag_ptr(ret_conv, true);
25165 void __attribute__((export_name("TS_HTLCUpdate_free"))) TS_HTLCUpdate_free(uint64_t this_obj) {
25166 LDKHTLCUpdate this_obj_conv;
25167 this_obj_conv.inner = untag_ptr(this_obj);
25168 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25170 HTLCUpdate_free(this_obj_conv);
25173 static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
25174 LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
25175 uint64_t ret_ref = 0;
25176 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25177 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25180 int64_t __attribute__((export_name("TS_HTLCUpdate_clone_ptr"))) TS_HTLCUpdate_clone_ptr(uint64_t arg) {
25181 LDKHTLCUpdate arg_conv;
25182 arg_conv.inner = untag_ptr(arg);
25183 arg_conv.is_owned = ptr_is_owned(arg);
25184 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25185 arg_conv.is_owned = false;
25186 int64_t ret_conv = HTLCUpdate_clone_ptr(&arg_conv);
25190 uint64_t __attribute__((export_name("TS_HTLCUpdate_clone"))) TS_HTLCUpdate_clone(uint64_t orig) {
25191 LDKHTLCUpdate orig_conv;
25192 orig_conv.inner = untag_ptr(orig);
25193 orig_conv.is_owned = ptr_is_owned(orig);
25194 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25195 orig_conv.is_owned = false;
25196 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
25197 uint64_t ret_ref = 0;
25198 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25199 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25203 jboolean __attribute__((export_name("TS_HTLCUpdate_eq"))) TS_HTLCUpdate_eq(uint64_t a, uint64_t b) {
25204 LDKHTLCUpdate a_conv;
25205 a_conv.inner = untag_ptr(a);
25206 a_conv.is_owned = ptr_is_owned(a);
25207 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25208 a_conv.is_owned = false;
25209 LDKHTLCUpdate b_conv;
25210 b_conv.inner = untag_ptr(b);
25211 b_conv.is_owned = ptr_is_owned(b);
25212 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25213 b_conv.is_owned = false;
25214 jboolean ret_conv = HTLCUpdate_eq(&a_conv, &b_conv);
25218 int8_tArray __attribute__((export_name("TS_HTLCUpdate_write"))) TS_HTLCUpdate_write(uint64_t obj) {
25219 LDKHTLCUpdate obj_conv;
25220 obj_conv.inner = untag_ptr(obj);
25221 obj_conv.is_owned = ptr_is_owned(obj);
25222 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25223 obj_conv.is_owned = false;
25224 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
25225 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25226 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25227 CVec_u8Z_free(ret_var);
25231 uint64_t __attribute__((export_name("TS_HTLCUpdate_read"))) TS_HTLCUpdate_read(int8_tArray ser) {
25232 LDKu8slice ser_ref;
25233 ser_ref.datalen = ser->arr_len;
25234 ser_ref.data = ser->elems;
25235 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
25236 *ret_conv = HTLCUpdate_read(ser_ref);
25238 return tag_ptr(ret_conv, true);
25241 void __attribute__((export_name("TS_Balance_free"))) TS_Balance_free(uint64_t this_ptr) {
25242 if (!ptr_is_owned(this_ptr)) return;
25243 void* this_ptr_ptr = untag_ptr(this_ptr);
25244 CHECK_ACCESS(this_ptr_ptr);
25245 LDKBalance this_ptr_conv = *(LDKBalance*)(this_ptr_ptr);
25246 FREE(untag_ptr(this_ptr));
25247 Balance_free(this_ptr_conv);
25250 static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
25251 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25252 *ret_copy = Balance_clone(arg);
25253 uint64_t ret_ref = tag_ptr(ret_copy, true);
25256 int64_t __attribute__((export_name("TS_Balance_clone_ptr"))) TS_Balance_clone_ptr(uint64_t arg) {
25257 LDKBalance* arg_conv = (LDKBalance*)untag_ptr(arg);
25258 int64_t ret_conv = Balance_clone_ptr(arg_conv);
25262 uint64_t __attribute__((export_name("TS_Balance_clone"))) TS_Balance_clone(uint64_t orig) {
25263 LDKBalance* orig_conv = (LDKBalance*)untag_ptr(orig);
25264 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25265 *ret_copy = Balance_clone(orig_conv);
25266 uint64_t ret_ref = tag_ptr(ret_copy, true);
25270 uint64_t __attribute__((export_name("TS_Balance_claimable_on_channel_close"))) TS_Balance_claimable_on_channel_close(int64_t claimable_amount_satoshis) {
25271 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25272 *ret_copy = Balance_claimable_on_channel_close(claimable_amount_satoshis);
25273 uint64_t ret_ref = tag_ptr(ret_copy, true);
25277 uint64_t __attribute__((export_name("TS_Balance_claimable_awaiting_confirmations"))) TS_Balance_claimable_awaiting_confirmations(int64_t claimable_amount_satoshis, int32_t confirmation_height) {
25278 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25279 *ret_copy = Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
25280 uint64_t ret_ref = tag_ptr(ret_copy, true);
25284 uint64_t __attribute__((export_name("TS_Balance_contentious_claimable"))) TS_Balance_contentious_claimable(int64_t claimable_amount_satoshis, int32_t timeout_height) {
25285 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25286 *ret_copy = Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
25287 uint64_t ret_ref = tag_ptr(ret_copy, true);
25291 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) {
25292 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25293 *ret_copy = Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
25294 uint64_t ret_ref = tag_ptr(ret_copy, true);
25298 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) {
25299 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25300 *ret_copy = Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
25301 uint64_t ret_ref = tag_ptr(ret_copy, true);
25305 uint64_t __attribute__((export_name("TS_Balance_counterparty_revoked_output_claimable"))) TS_Balance_counterparty_revoked_output_claimable(int64_t claimable_amount_satoshis) {
25306 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25307 *ret_copy = Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
25308 uint64_t ret_ref = tag_ptr(ret_copy, true);
25312 jboolean __attribute__((export_name("TS_Balance_eq"))) TS_Balance_eq(uint64_t a, uint64_t b) {
25313 LDKBalance* a_conv = (LDKBalance*)untag_ptr(a);
25314 LDKBalance* b_conv = (LDKBalance*)untag_ptr(b);
25315 jboolean ret_conv = Balance_eq(a_conv, b_conv);
25319 void __attribute__((export_name("TS_ChannelMonitor_free"))) TS_ChannelMonitor_free(uint64_t this_obj) {
25320 LDKChannelMonitor this_obj_conv;
25321 this_obj_conv.inner = untag_ptr(this_obj);
25322 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25323 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25324 ChannelMonitor_free(this_obj_conv);
25327 static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
25328 LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
25329 uint64_t ret_ref = 0;
25330 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25331 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25334 int64_t __attribute__((export_name("TS_ChannelMonitor_clone_ptr"))) TS_ChannelMonitor_clone_ptr(uint64_t arg) {
25335 LDKChannelMonitor arg_conv;
25336 arg_conv.inner = untag_ptr(arg);
25337 arg_conv.is_owned = ptr_is_owned(arg);
25338 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25339 arg_conv.is_owned = false;
25340 int64_t ret_conv = ChannelMonitor_clone_ptr(&arg_conv);
25344 uint64_t __attribute__((export_name("TS_ChannelMonitor_clone"))) TS_ChannelMonitor_clone(uint64_t orig) {
25345 LDKChannelMonitor orig_conv;
25346 orig_conv.inner = untag_ptr(orig);
25347 orig_conv.is_owned = ptr_is_owned(orig);
25348 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25349 orig_conv.is_owned = false;
25350 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
25351 uint64_t ret_ref = 0;
25352 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25353 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25357 int8_tArray __attribute__((export_name("TS_ChannelMonitor_write"))) TS_ChannelMonitor_write(uint64_t obj) {
25358 LDKChannelMonitor obj_conv;
25359 obj_conv.inner = untag_ptr(obj);
25360 obj_conv.is_owned = ptr_is_owned(obj);
25361 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25362 obj_conv.is_owned = false;
25363 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
25364 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25365 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25366 CVec_u8Z_free(ret_var);
25370 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) {
25371 LDKChannelMonitor this_arg_conv;
25372 this_arg_conv.inner = untag_ptr(this_arg);
25373 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25375 this_arg_conv.is_owned = false;
25376 LDKChannelMonitorUpdate updates_conv;
25377 updates_conv.inner = untag_ptr(updates);
25378 updates_conv.is_owned = ptr_is_owned(updates);
25379 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
25380 updates_conv.is_owned = false;
25381 void* broadcaster_ptr = untag_ptr(broadcaster);
25382 if (ptr_is_owned(broadcaster)) { CHECK_ACCESS(broadcaster_ptr); }
25383 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
25384 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25385 CHECK_ACCESS(fee_estimator_ptr);
25386 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25387 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25388 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25389 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25391 void* logger_ptr = untag_ptr(logger);
25392 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
25393 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
25394 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
25395 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
25396 return tag_ptr(ret_conv, true);
25399 int64_t __attribute__((export_name("TS_ChannelMonitor_get_latest_update_id"))) TS_ChannelMonitor_get_latest_update_id(uint64_t this_arg) {
25400 LDKChannelMonitor this_arg_conv;
25401 this_arg_conv.inner = untag_ptr(this_arg);
25402 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25403 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25404 this_arg_conv.is_owned = false;
25405 int64_t ret_conv = ChannelMonitor_get_latest_update_id(&this_arg_conv);
25409 uint64_t __attribute__((export_name("TS_ChannelMonitor_get_funding_txo"))) TS_ChannelMonitor_get_funding_txo(uint64_t this_arg) {
25410 LDKChannelMonitor this_arg_conv;
25411 this_arg_conv.inner = untag_ptr(this_arg);
25412 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25414 this_arg_conv.is_owned = false;
25415 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
25416 *ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
25417 return tag_ptr(ret_conv, true);
25420 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_outputs_to_watch"))) TS_ChannelMonitor_get_outputs_to_watch(uint64_t this_arg) {
25421 LDKChannelMonitor this_arg_conv;
25422 this_arg_conv.inner = untag_ptr(this_arg);
25423 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25424 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25425 this_arg_conv.is_owned = false;
25426 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
25427 uint64_tArray ret_arr = NULL;
25428 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25429 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25430 for (size_t o = 0; o < ret_var.datalen; o++) {
25431 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
25432 *ret_conv_40_conv = ret_var.data[o];
25433 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
25436 FREE(ret_var.data);
25440 void __attribute__((export_name("TS_ChannelMonitor_load_outputs_to_watch"))) TS_ChannelMonitor_load_outputs_to_watch(uint64_t this_arg, uint64_t filter) {
25441 LDKChannelMonitor this_arg_conv;
25442 this_arg_conv.inner = untag_ptr(this_arg);
25443 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25444 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25445 this_arg_conv.is_owned = false;
25446 void* filter_ptr = untag_ptr(filter);
25447 if (ptr_is_owned(filter)) { CHECK_ACCESS(filter_ptr); }
25448 LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
25449 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
25452 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) {
25453 LDKChannelMonitor this_arg_conv;
25454 this_arg_conv.inner = untag_ptr(this_arg);
25455 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25456 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25457 this_arg_conv.is_owned = false;
25458 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
25459 uint64_tArray ret_arr = NULL;
25460 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25461 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25462 for (size_t o = 0; o < ret_var.datalen; o++) {
25463 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25464 *ret_conv_14_copy = ret_var.data[o];
25465 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
25466 ret_arr_ptr[o] = ret_conv_14_ref;
25469 FREE(ret_var.data);
25473 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_and_clear_pending_events"))) TS_ChannelMonitor_get_and_clear_pending_events(uint64_t this_arg) {
25474 LDKChannelMonitor this_arg_conv;
25475 this_arg_conv.inner = untag_ptr(this_arg);
25476 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25478 this_arg_conv.is_owned = false;
25479 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
25480 uint64_tArray ret_arr = NULL;
25481 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25482 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25483 for (size_t h = 0; h < ret_var.datalen; h++) {
25484 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
25485 *ret_conv_7_copy = ret_var.data[h];
25486 uint64_t ret_conv_7_ref = tag_ptr(ret_conv_7_copy, true);
25487 ret_arr_ptr[h] = ret_conv_7_ref;
25490 FREE(ret_var.data);
25494 int8_tArray __attribute__((export_name("TS_ChannelMonitor_get_counterparty_node_id"))) TS_ChannelMonitor_get_counterparty_node_id(uint64_t this_arg) {
25495 LDKChannelMonitor this_arg_conv;
25496 this_arg_conv.inner = untag_ptr(this_arg);
25497 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25499 this_arg_conv.is_owned = false;
25500 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
25501 memcpy(ret_arr->elems, ChannelMonitor_get_counterparty_node_id(&this_arg_conv).compressed_form, 33);
25505 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) {
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 void* logger_ptr = untag_ptr(logger);
25512 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
25513 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
25514 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
25515 ptrArray ret_arr = NULL;
25516 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
25517 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
25518 for (size_t m = 0; m < ret_var.datalen; m++) {
25519 LDKTransaction ret_conv_12_var = ret_var.data[m];
25520 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
25521 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
25522 Transaction_free(ret_conv_12_var);
25523 ret_arr_ptr[m] = ret_conv_12_arr;
25526 FREE(ret_var.data);
25530 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) {
25531 LDKChannelMonitor this_arg_conv;
25532 this_arg_conv.inner = untag_ptr(this_arg);
25533 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25535 this_arg_conv.is_owned = false;
25536 uint8_t header_arr[80];
25537 CHECK(header->arr_len == 80);
25538 memcpy(header_arr, header->elems, 80); FREE(header);
25539 uint8_t (*header_ref)[80] = &header_arr;
25540 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
25541 txdata_constr.datalen = txdata->arr_len;
25542 if (txdata_constr.datalen > 0)
25543 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
25545 txdata_constr.data = NULL;
25546 uint64_t* txdata_vals = txdata->elems;
25547 for (size_t c = 0; c < txdata_constr.datalen; c++) {
25548 uint64_t txdata_conv_28 = txdata_vals[c];
25549 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
25550 CHECK_ACCESS(txdata_conv_28_ptr);
25551 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
25552 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
25553 txdata_constr.data[c] = txdata_conv_28_conv;
25556 void* broadcaster_ptr = untag_ptr(broadcaster);
25557 CHECK_ACCESS(broadcaster_ptr);
25558 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25559 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25560 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25561 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25563 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25564 CHECK_ACCESS(fee_estimator_ptr);
25565 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25566 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25567 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25568 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25570 void* logger_ptr = untag_ptr(logger);
25571 CHECK_ACCESS(logger_ptr);
25572 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25573 if (logger_conv.free == LDKLogger_JCalls_free) {
25574 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25575 LDKLogger_JCalls_cloned(&logger_conv);
25577 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);
25578 uint64_tArray ret_arr = NULL;
25579 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25580 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25581 for (size_t n = 0; n < ret_var.datalen; n++) {
25582 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25583 *ret_conv_39_conv = ret_var.data[n];
25584 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25587 FREE(ret_var.data);
25591 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) {
25592 LDKChannelMonitor this_arg_conv;
25593 this_arg_conv.inner = untag_ptr(this_arg);
25594 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25596 this_arg_conv.is_owned = false;
25597 uint8_t header_arr[80];
25598 CHECK(header->arr_len == 80);
25599 memcpy(header_arr, header->elems, 80); FREE(header);
25600 uint8_t (*header_ref)[80] = &header_arr;
25601 void* broadcaster_ptr = untag_ptr(broadcaster);
25602 CHECK_ACCESS(broadcaster_ptr);
25603 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25604 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25605 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25606 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25608 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25609 CHECK_ACCESS(fee_estimator_ptr);
25610 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25611 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25612 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25613 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25615 void* logger_ptr = untag_ptr(logger);
25616 CHECK_ACCESS(logger_ptr);
25617 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25618 if (logger_conv.free == LDKLogger_JCalls_free) {
25619 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25620 LDKLogger_JCalls_cloned(&logger_conv);
25622 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25625 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) {
25626 LDKChannelMonitor this_arg_conv;
25627 this_arg_conv.inner = untag_ptr(this_arg);
25628 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25630 this_arg_conv.is_owned = false;
25631 uint8_t header_arr[80];
25632 CHECK(header->arr_len == 80);
25633 memcpy(header_arr, header->elems, 80); FREE(header);
25634 uint8_t (*header_ref)[80] = &header_arr;
25635 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
25636 txdata_constr.datalen = txdata->arr_len;
25637 if (txdata_constr.datalen > 0)
25638 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
25640 txdata_constr.data = NULL;
25641 uint64_t* txdata_vals = txdata->elems;
25642 for (size_t c = 0; c < txdata_constr.datalen; c++) {
25643 uint64_t txdata_conv_28 = txdata_vals[c];
25644 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
25645 CHECK_ACCESS(txdata_conv_28_ptr);
25646 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
25647 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
25648 txdata_constr.data[c] = txdata_conv_28_conv;
25651 void* broadcaster_ptr = untag_ptr(broadcaster);
25652 CHECK_ACCESS(broadcaster_ptr);
25653 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25654 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25655 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25656 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25658 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25659 CHECK_ACCESS(fee_estimator_ptr);
25660 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25661 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25662 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25663 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25665 void* logger_ptr = untag_ptr(logger);
25666 CHECK_ACCESS(logger_ptr);
25667 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25668 if (logger_conv.free == LDKLogger_JCalls_free) {
25669 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25670 LDKLogger_JCalls_cloned(&logger_conv);
25672 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);
25673 uint64_tArray ret_arr = NULL;
25674 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25675 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25676 for (size_t n = 0; n < ret_var.datalen; n++) {
25677 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25678 *ret_conv_39_conv = ret_var.data[n];
25679 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25682 FREE(ret_var.data);
25686 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) {
25687 LDKChannelMonitor this_arg_conv;
25688 this_arg_conv.inner = untag_ptr(this_arg);
25689 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25691 this_arg_conv.is_owned = false;
25692 uint8_t txid_arr[32];
25693 CHECK(txid->arr_len == 32);
25694 memcpy(txid_arr, txid->elems, 32); FREE(txid);
25695 uint8_t (*txid_ref)[32] = &txid_arr;
25696 void* broadcaster_ptr = untag_ptr(broadcaster);
25697 CHECK_ACCESS(broadcaster_ptr);
25698 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25699 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25700 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25701 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25703 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25704 CHECK_ACCESS(fee_estimator_ptr);
25705 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25706 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25707 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25708 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25710 void* logger_ptr = untag_ptr(logger);
25711 CHECK_ACCESS(logger_ptr);
25712 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25713 if (logger_conv.free == LDKLogger_JCalls_free) {
25714 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25715 LDKLogger_JCalls_cloned(&logger_conv);
25717 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
25720 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) {
25721 LDKChannelMonitor this_arg_conv;
25722 this_arg_conv.inner = untag_ptr(this_arg);
25723 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25724 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25725 this_arg_conv.is_owned = false;
25726 uint8_t header_arr[80];
25727 CHECK(header->arr_len == 80);
25728 memcpy(header_arr, header->elems, 80); FREE(header);
25729 uint8_t (*header_ref)[80] = &header_arr;
25730 void* broadcaster_ptr = untag_ptr(broadcaster);
25731 CHECK_ACCESS(broadcaster_ptr);
25732 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25733 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25734 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25735 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25737 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25738 CHECK_ACCESS(fee_estimator_ptr);
25739 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25740 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25741 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25742 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25744 void* logger_ptr = untag_ptr(logger);
25745 CHECK_ACCESS(logger_ptr);
25746 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25747 if (logger_conv.free == LDKLogger_JCalls_free) {
25748 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25749 LDKLogger_JCalls_cloned(&logger_conv);
25751 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25752 uint64_tArray ret_arr = NULL;
25753 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25754 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25755 for (size_t n = 0; n < ret_var.datalen; n++) {
25756 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25757 *ret_conv_39_conv = ret_var.data[n];
25758 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25761 FREE(ret_var.data);
25765 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_relevant_txids"))) TS_ChannelMonitor_get_relevant_txids(uint64_t this_arg) {
25766 LDKChannelMonitor this_arg_conv;
25767 this_arg_conv.inner = untag_ptr(this_arg);
25768 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25770 this_arg_conv.is_owned = false;
25771 LDKCVec_C2Tuple_TxidBlockHashZZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
25772 uint64_tArray ret_arr = NULL;
25773 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25774 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25775 for (size_t z = 0; z < ret_var.datalen; z++) {
25776 LDKC2Tuple_TxidBlockHashZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
25777 *ret_conv_25_conv = ret_var.data[z];
25778 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
25781 FREE(ret_var.data);
25785 uint64_t __attribute__((export_name("TS_ChannelMonitor_current_best_block"))) TS_ChannelMonitor_current_best_block(uint64_t this_arg) {
25786 LDKChannelMonitor this_arg_conv;
25787 this_arg_conv.inner = untag_ptr(this_arg);
25788 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25790 this_arg_conv.is_owned = false;
25791 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
25792 uint64_t ret_ref = 0;
25793 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25794 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25798 void __attribute__((export_name("TS_ChannelMonitor_rebroadcast_pending_claims"))) TS_ChannelMonitor_rebroadcast_pending_claims(uint64_t this_arg, uint64_t broadcaster, uint64_t fee_estimator, uint64_t logger) {
25799 LDKChannelMonitor this_arg_conv;
25800 this_arg_conv.inner = untag_ptr(this_arg);
25801 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25802 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25803 this_arg_conv.is_owned = false;
25804 void* broadcaster_ptr = untag_ptr(broadcaster);
25805 CHECK_ACCESS(broadcaster_ptr);
25806 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25807 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25808 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25809 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25811 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25812 CHECK_ACCESS(fee_estimator_ptr);
25813 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25814 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25815 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25816 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25818 void* logger_ptr = untag_ptr(logger);
25819 CHECK_ACCESS(logger_ptr);
25820 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25821 if (logger_conv.free == LDKLogger_JCalls_free) {
25822 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25823 LDKLogger_JCalls_cloned(&logger_conv);
25825 ChannelMonitor_rebroadcast_pending_claims(&this_arg_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
25828 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_claimable_balances"))) TS_ChannelMonitor_get_claimable_balances(uint64_t this_arg) {
25829 LDKChannelMonitor this_arg_conv;
25830 this_arg_conv.inner = untag_ptr(this_arg);
25831 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25832 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25833 this_arg_conv.is_owned = false;
25834 LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
25835 uint64_tArray ret_arr = NULL;
25836 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25837 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25838 for (size_t j = 0; j < ret_var.datalen; j++) {
25839 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25840 *ret_conv_9_copy = ret_var.data[j];
25841 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
25842 ret_arr_ptr[j] = ret_conv_9_ref;
25845 FREE(ret_var.data);
25849 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_read"))) TS_C2Tuple_BlockHashChannelMonitorZ_read(int8_tArray ser, uint64_t arg_a, uint64_t arg_b) {
25850 LDKu8slice ser_ref;
25851 ser_ref.datalen = ser->arr_len;
25852 ser_ref.data = ser->elems;
25853 void* arg_a_ptr = untag_ptr(arg_a);
25854 if (ptr_is_owned(arg_a)) { CHECK_ACCESS(arg_a_ptr); }
25855 LDKEntropySource* arg_a_conv = (LDKEntropySource*)arg_a_ptr;
25856 void* arg_b_ptr = untag_ptr(arg_b);
25857 if (ptr_is_owned(arg_b)) { CHECK_ACCESS(arg_b_ptr); }
25858 LDKSignerProvider* arg_b_conv = (LDKSignerProvider*)arg_b_ptr;
25859 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
25860 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_a_conv, arg_b_conv);
25862 return tag_ptr(ret_conv, true);
25865 void __attribute__((export_name("TS_OutPoint_free"))) TS_OutPoint_free(uint64_t this_obj) {
25866 LDKOutPoint this_obj_conv;
25867 this_obj_conv.inner = untag_ptr(this_obj);
25868 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25869 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25870 OutPoint_free(this_obj_conv);
25873 int8_tArray __attribute__((export_name("TS_OutPoint_get_txid"))) TS_OutPoint_get_txid(uint64_t this_ptr) {
25874 LDKOutPoint this_ptr_conv;
25875 this_ptr_conv.inner = untag_ptr(this_ptr);
25876 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25878 this_ptr_conv.is_owned = false;
25879 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25880 memcpy(ret_arr->elems, *OutPoint_get_txid(&this_ptr_conv), 32);
25884 void __attribute__((export_name("TS_OutPoint_set_txid"))) TS_OutPoint_set_txid(uint64_t this_ptr, int8_tArray val) {
25885 LDKOutPoint this_ptr_conv;
25886 this_ptr_conv.inner = untag_ptr(this_ptr);
25887 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25888 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25889 this_ptr_conv.is_owned = false;
25890 LDKThirtyTwoBytes val_ref;
25891 CHECK(val->arr_len == 32);
25892 memcpy(val_ref.data, val->elems, 32); FREE(val);
25893 OutPoint_set_txid(&this_ptr_conv, val_ref);
25896 int16_t __attribute__((export_name("TS_OutPoint_get_index"))) TS_OutPoint_get_index(uint64_t this_ptr) {
25897 LDKOutPoint this_ptr_conv;
25898 this_ptr_conv.inner = untag_ptr(this_ptr);
25899 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25900 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25901 this_ptr_conv.is_owned = false;
25902 int16_t ret_conv = OutPoint_get_index(&this_ptr_conv);
25906 void __attribute__((export_name("TS_OutPoint_set_index"))) TS_OutPoint_set_index(uint64_t this_ptr, int16_t val) {
25907 LDKOutPoint this_ptr_conv;
25908 this_ptr_conv.inner = untag_ptr(this_ptr);
25909 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25911 this_ptr_conv.is_owned = false;
25912 OutPoint_set_index(&this_ptr_conv, val);
25915 uint64_t __attribute__((export_name("TS_OutPoint_new"))) TS_OutPoint_new(int8_tArray txid_arg, int16_t index_arg) {
25916 LDKThirtyTwoBytes txid_arg_ref;
25917 CHECK(txid_arg->arr_len == 32);
25918 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
25919 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
25920 uint64_t ret_ref = 0;
25921 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25922 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25926 static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
25927 LDKOutPoint ret_var = OutPoint_clone(arg);
25928 uint64_t ret_ref = 0;
25929 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25930 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25933 int64_t __attribute__((export_name("TS_OutPoint_clone_ptr"))) TS_OutPoint_clone_ptr(uint64_t arg) {
25934 LDKOutPoint arg_conv;
25935 arg_conv.inner = untag_ptr(arg);
25936 arg_conv.is_owned = ptr_is_owned(arg);
25937 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25938 arg_conv.is_owned = false;
25939 int64_t ret_conv = OutPoint_clone_ptr(&arg_conv);
25943 uint64_t __attribute__((export_name("TS_OutPoint_clone"))) TS_OutPoint_clone(uint64_t orig) {
25944 LDKOutPoint orig_conv;
25945 orig_conv.inner = untag_ptr(orig);
25946 orig_conv.is_owned = ptr_is_owned(orig);
25947 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25948 orig_conv.is_owned = false;
25949 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
25950 uint64_t ret_ref = 0;
25951 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25952 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25956 jboolean __attribute__((export_name("TS_OutPoint_eq"))) TS_OutPoint_eq(uint64_t a, uint64_t b) {
25957 LDKOutPoint a_conv;
25958 a_conv.inner = untag_ptr(a);
25959 a_conv.is_owned = ptr_is_owned(a);
25960 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25961 a_conv.is_owned = false;
25962 LDKOutPoint b_conv;
25963 b_conv.inner = untag_ptr(b);
25964 b_conv.is_owned = ptr_is_owned(b);
25965 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25966 b_conv.is_owned = false;
25967 jboolean ret_conv = OutPoint_eq(&a_conv, &b_conv);
25971 int64_t __attribute__((export_name("TS_OutPoint_hash"))) TS_OutPoint_hash(uint64_t o) {
25972 LDKOutPoint o_conv;
25973 o_conv.inner = untag_ptr(o);
25974 o_conv.is_owned = ptr_is_owned(o);
25975 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25976 o_conv.is_owned = false;
25977 int64_t ret_conv = OutPoint_hash(&o_conv);
25981 int8_tArray __attribute__((export_name("TS_OutPoint_to_channel_id"))) TS_OutPoint_to_channel_id(uint64_t this_arg) {
25982 LDKOutPoint this_arg_conv;
25983 this_arg_conv.inner = untag_ptr(this_arg);
25984 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25986 this_arg_conv.is_owned = false;
25987 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25988 memcpy(ret_arr->elems, OutPoint_to_channel_id(&this_arg_conv).data, 32);
25992 int8_tArray __attribute__((export_name("TS_OutPoint_write"))) TS_OutPoint_write(uint64_t obj) {
25993 LDKOutPoint obj_conv;
25994 obj_conv.inner = untag_ptr(obj);
25995 obj_conv.is_owned = ptr_is_owned(obj);
25996 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25997 obj_conv.is_owned = false;
25998 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
25999 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26000 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26001 CVec_u8Z_free(ret_var);
26005 uint64_t __attribute__((export_name("TS_OutPoint_read"))) TS_OutPoint_read(int8_tArray ser) {
26006 LDKu8slice ser_ref;
26007 ser_ref.datalen = ser->arr_len;
26008 ser_ref.data = ser->elems;
26009 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
26010 *ret_conv = OutPoint_read(ser_ref);
26012 return tag_ptr(ret_conv, true);
26015 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_free"))) TS_DelayedPaymentOutputDescriptor_free(uint64_t this_obj) {
26016 LDKDelayedPaymentOutputDescriptor this_obj_conv;
26017 this_obj_conv.inner = untag_ptr(this_obj);
26018 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26020 DelayedPaymentOutputDescriptor_free(this_obj_conv);
26023 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_outpoint"))) TS_DelayedPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
26024 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26025 this_ptr_conv.inner = untag_ptr(this_ptr);
26026 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26028 this_ptr_conv.is_owned = false;
26029 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
26030 uint64_t ret_ref = 0;
26031 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26032 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26036 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_outpoint"))) TS_DelayedPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
26037 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26038 this_ptr_conv.inner = untag_ptr(this_ptr);
26039 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26040 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26041 this_ptr_conv.is_owned = false;
26042 LDKOutPoint val_conv;
26043 val_conv.inner = untag_ptr(val);
26044 val_conv.is_owned = ptr_is_owned(val);
26045 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26046 val_conv = OutPoint_clone(&val_conv);
26047 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
26050 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(uint64_t this_ptr) {
26051 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26052 this_ptr_conv.inner = untag_ptr(this_ptr);
26053 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26054 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26055 this_ptr_conv.is_owned = false;
26056 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
26057 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
26061 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
26062 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26063 this_ptr_conv.inner = untag_ptr(this_ptr);
26064 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26065 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26066 this_ptr_conv.is_owned = false;
26067 LDKPublicKey val_ref;
26068 CHECK(val->arr_len == 33);
26069 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
26070 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
26073 int16_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_get_to_self_delay(uint64_t this_ptr) {
26074 LDKDelayedPaymentOutputDescriptor 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 int16_t ret_conv = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
26083 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_set_to_self_delay(uint64_t this_ptr, int16_t val) {
26084 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26085 this_ptr_conv.inner = untag_ptr(this_ptr);
26086 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26087 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26088 this_ptr_conv.is_owned = false;
26089 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
26092 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_output"))) TS_DelayedPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
26093 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26094 this_ptr_conv.inner = untag_ptr(this_ptr);
26095 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26096 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26097 this_ptr_conv.is_owned = false;
26098 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
26099 *ret_ref = DelayedPaymentOutputDescriptor_get_output(&this_ptr_conv);
26100 return tag_ptr(ret_ref, true);
26103 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_output"))) TS_DelayedPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
26104 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26105 this_ptr_conv.inner = untag_ptr(this_ptr);
26106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26108 this_ptr_conv.is_owned = false;
26109 void* val_ptr = untag_ptr(val);
26110 CHECK_ACCESS(val_ptr);
26111 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
26112 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
26113 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
26116 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(uint64_t this_ptr) {
26117 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26118 this_ptr_conv.inner = untag_ptr(this_ptr);
26119 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26121 this_ptr_conv.is_owned = false;
26122 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
26123 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
26127 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(uint64_t this_ptr, int8_tArray val) {
26128 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26129 this_ptr_conv.inner = untag_ptr(this_ptr);
26130 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26132 this_ptr_conv.is_owned = false;
26133 LDKPublicKey val_ref;
26134 CHECK(val->arr_len == 33);
26135 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
26136 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
26139 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
26140 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26141 this_ptr_conv.inner = untag_ptr(this_ptr);
26142 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26144 this_ptr_conv.is_owned = false;
26145 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26146 memcpy(ret_arr->elems, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
26150 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
26151 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26152 this_ptr_conv.inner = untag_ptr(this_ptr);
26153 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26155 this_ptr_conv.is_owned = false;
26156 LDKThirtyTwoBytes val_ref;
26157 CHECK(val->arr_len == 32);
26158 memcpy(val_ref.data, val->elems, 32); FREE(val);
26159 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
26162 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
26163 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26164 this_ptr_conv.inner = untag_ptr(this_ptr);
26165 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26167 this_ptr_conv.is_owned = false;
26168 int64_t ret_conv = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
26172 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
26173 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26174 this_ptr_conv.inner = untag_ptr(this_ptr);
26175 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26177 this_ptr_conv.is_owned = false;
26178 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
26181 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) {
26182 LDKOutPoint outpoint_arg_conv;
26183 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
26184 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
26185 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
26186 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
26187 LDKPublicKey per_commitment_point_arg_ref;
26188 CHECK(per_commitment_point_arg->arr_len == 33);
26189 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
26190 void* output_arg_ptr = untag_ptr(output_arg);
26191 CHECK_ACCESS(output_arg_ptr);
26192 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
26193 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
26194 LDKPublicKey revocation_pubkey_arg_ref;
26195 CHECK(revocation_pubkey_arg->arr_len == 33);
26196 memcpy(revocation_pubkey_arg_ref.compressed_form, revocation_pubkey_arg->elems, 33); FREE(revocation_pubkey_arg);
26197 LDKThirtyTwoBytes channel_keys_id_arg_ref;
26198 CHECK(channel_keys_id_arg->arr_len == 32);
26199 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
26200 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);
26201 uint64_t ret_ref = 0;
26202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26207 static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
26208 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
26209 uint64_t ret_ref = 0;
26210 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26211 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26214 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone_ptr"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
26215 LDKDelayedPaymentOutputDescriptor arg_conv;
26216 arg_conv.inner = untag_ptr(arg);
26217 arg_conv.is_owned = ptr_is_owned(arg);
26218 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26219 arg_conv.is_owned = false;
26220 int64_t ret_conv = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
26224 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone"))) TS_DelayedPaymentOutputDescriptor_clone(uint64_t orig) {
26225 LDKDelayedPaymentOutputDescriptor orig_conv;
26226 orig_conv.inner = untag_ptr(orig);
26227 orig_conv.is_owned = ptr_is_owned(orig);
26228 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26229 orig_conv.is_owned = false;
26230 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
26231 uint64_t ret_ref = 0;
26232 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26233 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26237 jboolean __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_eq"))) TS_DelayedPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
26238 LDKDelayedPaymentOutputDescriptor a_conv;
26239 a_conv.inner = untag_ptr(a);
26240 a_conv.is_owned = ptr_is_owned(a);
26241 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26242 a_conv.is_owned = false;
26243 LDKDelayedPaymentOutputDescriptor b_conv;
26244 b_conv.inner = untag_ptr(b);
26245 b_conv.is_owned = ptr_is_owned(b);
26246 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
26247 b_conv.is_owned = false;
26248 jboolean ret_conv = DelayedPaymentOutputDescriptor_eq(&a_conv, &b_conv);
26252 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_write"))) TS_DelayedPaymentOutputDescriptor_write(uint64_t obj) {
26253 LDKDelayedPaymentOutputDescriptor obj_conv;
26254 obj_conv.inner = untag_ptr(obj);
26255 obj_conv.is_owned = ptr_is_owned(obj);
26256 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26257 obj_conv.is_owned = false;
26258 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
26259 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26260 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26261 CVec_u8Z_free(ret_var);
26265 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_read"))) TS_DelayedPaymentOutputDescriptor_read(int8_tArray ser) {
26266 LDKu8slice ser_ref;
26267 ser_ref.datalen = ser->arr_len;
26268 ser_ref.data = ser->elems;
26269 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
26270 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
26272 return tag_ptr(ret_conv, true);
26275 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_free"))) TS_StaticPaymentOutputDescriptor_free(uint64_t this_obj) {
26276 LDKStaticPaymentOutputDescriptor this_obj_conv;
26277 this_obj_conv.inner = untag_ptr(this_obj);
26278 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26280 StaticPaymentOutputDescriptor_free(this_obj_conv);
26283 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_outpoint"))) TS_StaticPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
26284 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26285 this_ptr_conv.inner = untag_ptr(this_ptr);
26286 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26288 this_ptr_conv.is_owned = false;
26289 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
26290 uint64_t ret_ref = 0;
26291 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26292 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26296 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_outpoint"))) TS_StaticPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
26297 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26298 this_ptr_conv.inner = untag_ptr(this_ptr);
26299 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26300 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26301 this_ptr_conv.is_owned = false;
26302 LDKOutPoint val_conv;
26303 val_conv.inner = untag_ptr(val);
26304 val_conv.is_owned = ptr_is_owned(val);
26305 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26306 val_conv = OutPoint_clone(&val_conv);
26307 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
26310 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_output"))) TS_StaticPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
26311 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26312 this_ptr_conv.inner = untag_ptr(this_ptr);
26313 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26314 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26315 this_ptr_conv.is_owned = false;
26316 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
26317 *ret_ref = StaticPaymentOutputDescriptor_get_output(&this_ptr_conv);
26318 return tag_ptr(ret_ref, true);
26321 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_output"))) TS_StaticPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
26322 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26323 this_ptr_conv.inner = untag_ptr(this_ptr);
26324 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26326 this_ptr_conv.is_owned = false;
26327 void* val_ptr = untag_ptr(val);
26328 CHECK_ACCESS(val_ptr);
26329 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
26330 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
26331 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
26334 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
26335 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26336 this_ptr_conv.inner = untag_ptr(this_ptr);
26337 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26339 this_ptr_conv.is_owned = false;
26340 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26341 memcpy(ret_arr->elems, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
26345 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
26346 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26347 this_ptr_conv.inner = untag_ptr(this_ptr);
26348 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26349 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26350 this_ptr_conv.is_owned = false;
26351 LDKThirtyTwoBytes val_ref;
26352 CHECK(val->arr_len == 32);
26353 memcpy(val_ref.data, val->elems, 32); FREE(val);
26354 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
26357 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
26358 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26359 this_ptr_conv.inner = untag_ptr(this_ptr);
26360 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26361 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26362 this_ptr_conv.is_owned = false;
26363 int64_t ret_conv = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
26367 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
26368 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26369 this_ptr_conv.inner = untag_ptr(this_ptr);
26370 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26372 this_ptr_conv.is_owned = false;
26373 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
26376 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) {
26377 LDKOutPoint outpoint_arg_conv;
26378 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
26379 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
26380 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
26381 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
26382 void* output_arg_ptr = untag_ptr(output_arg);
26383 CHECK_ACCESS(output_arg_ptr);
26384 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
26385 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
26386 LDKThirtyTwoBytes channel_keys_id_arg_ref;
26387 CHECK(channel_keys_id_arg->arr_len == 32);
26388 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
26389 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
26390 uint64_t ret_ref = 0;
26391 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26392 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26396 static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
26397 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
26398 uint64_t ret_ref = 0;
26399 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26400 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26403 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone_ptr"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
26404 LDKStaticPaymentOutputDescriptor arg_conv;
26405 arg_conv.inner = untag_ptr(arg);
26406 arg_conv.is_owned = ptr_is_owned(arg);
26407 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26408 arg_conv.is_owned = false;
26409 int64_t ret_conv = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
26413 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone"))) TS_StaticPaymentOutputDescriptor_clone(uint64_t orig) {
26414 LDKStaticPaymentOutputDescriptor orig_conv;
26415 orig_conv.inner = untag_ptr(orig);
26416 orig_conv.is_owned = ptr_is_owned(orig);
26417 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26418 orig_conv.is_owned = false;
26419 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
26420 uint64_t ret_ref = 0;
26421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26426 jboolean __attribute__((export_name("TS_StaticPaymentOutputDescriptor_eq"))) TS_StaticPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
26427 LDKStaticPaymentOutputDescriptor a_conv;
26428 a_conv.inner = untag_ptr(a);
26429 a_conv.is_owned = ptr_is_owned(a);
26430 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26431 a_conv.is_owned = false;
26432 LDKStaticPaymentOutputDescriptor b_conv;
26433 b_conv.inner = untag_ptr(b);
26434 b_conv.is_owned = ptr_is_owned(b);
26435 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
26436 b_conv.is_owned = false;
26437 jboolean ret_conv = StaticPaymentOutputDescriptor_eq(&a_conv, &b_conv);
26441 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_write"))) TS_StaticPaymentOutputDescriptor_write(uint64_t obj) {
26442 LDKStaticPaymentOutputDescriptor obj_conv;
26443 obj_conv.inner = untag_ptr(obj);
26444 obj_conv.is_owned = ptr_is_owned(obj);
26445 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26446 obj_conv.is_owned = false;
26447 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
26448 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26449 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26450 CVec_u8Z_free(ret_var);
26454 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_read"))) TS_StaticPaymentOutputDescriptor_read(int8_tArray ser) {
26455 LDKu8slice ser_ref;
26456 ser_ref.datalen = ser->arr_len;
26457 ser_ref.data = ser->elems;
26458 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
26459 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
26461 return tag_ptr(ret_conv, true);
26464 void __attribute__((export_name("TS_SpendableOutputDescriptor_free"))) TS_SpendableOutputDescriptor_free(uint64_t this_ptr) {
26465 if (!ptr_is_owned(this_ptr)) return;
26466 void* this_ptr_ptr = untag_ptr(this_ptr);
26467 CHECK_ACCESS(this_ptr_ptr);
26468 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(this_ptr_ptr);
26469 FREE(untag_ptr(this_ptr));
26470 SpendableOutputDescriptor_free(this_ptr_conv);
26473 static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
26474 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26475 *ret_copy = SpendableOutputDescriptor_clone(arg);
26476 uint64_t ret_ref = tag_ptr(ret_copy, true);
26479 int64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone_ptr"))) TS_SpendableOutputDescriptor_clone_ptr(uint64_t arg) {
26480 LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)untag_ptr(arg);
26481 int64_t ret_conv = SpendableOutputDescriptor_clone_ptr(arg_conv);
26485 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone"))) TS_SpendableOutputDescriptor_clone(uint64_t orig) {
26486 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)untag_ptr(orig);
26487 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26488 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
26489 uint64_t ret_ref = tag_ptr(ret_copy, true);
26493 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_output"))) TS_SpendableOutputDescriptor_static_output(uint64_t outpoint, uint64_t output) {
26494 LDKOutPoint outpoint_conv;
26495 outpoint_conv.inner = untag_ptr(outpoint);
26496 outpoint_conv.is_owned = ptr_is_owned(outpoint);
26497 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
26498 outpoint_conv = OutPoint_clone(&outpoint_conv);
26499 void* output_ptr = untag_ptr(output);
26500 CHECK_ACCESS(output_ptr);
26501 LDKTxOut output_conv = *(LDKTxOut*)(output_ptr);
26502 output_conv = TxOut_clone((LDKTxOut*)untag_ptr(output));
26503 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26504 *ret_copy = SpendableOutputDescriptor_static_output(outpoint_conv, output_conv);
26505 uint64_t ret_ref = tag_ptr(ret_copy, true);
26509 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_delayed_payment_output"))) TS_SpendableOutputDescriptor_delayed_payment_output(uint64_t a) {
26510 LDKDelayedPaymentOutputDescriptor a_conv;
26511 a_conv.inner = untag_ptr(a);
26512 a_conv.is_owned = ptr_is_owned(a);
26513 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26514 a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
26515 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26516 *ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
26517 uint64_t ret_ref = tag_ptr(ret_copy, true);
26521 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_payment_output"))) TS_SpendableOutputDescriptor_static_payment_output(uint64_t a) {
26522 LDKStaticPaymentOutputDescriptor a_conv;
26523 a_conv.inner = untag_ptr(a);
26524 a_conv.is_owned = ptr_is_owned(a);
26525 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26526 a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
26527 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26528 *ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
26529 uint64_t ret_ref = tag_ptr(ret_copy, true);
26533 jboolean __attribute__((export_name("TS_SpendableOutputDescriptor_eq"))) TS_SpendableOutputDescriptor_eq(uint64_t a, uint64_t b) {
26534 LDKSpendableOutputDescriptor* a_conv = (LDKSpendableOutputDescriptor*)untag_ptr(a);
26535 LDKSpendableOutputDescriptor* b_conv = (LDKSpendableOutputDescriptor*)untag_ptr(b);
26536 jboolean ret_conv = SpendableOutputDescriptor_eq(a_conv, b_conv);
26540 int8_tArray __attribute__((export_name("TS_SpendableOutputDescriptor_write"))) TS_SpendableOutputDescriptor_write(uint64_t obj) {
26541 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)untag_ptr(obj);
26542 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
26543 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26544 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26545 CVec_u8Z_free(ret_var);
26549 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_read"))) TS_SpendableOutputDescriptor_read(int8_tArray ser) {
26550 LDKu8slice ser_ref;
26551 ser_ref.datalen = ser->arr_len;
26552 ser_ref.data = ser->elems;
26553 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
26554 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
26556 return tag_ptr(ret_conv, true);
26559 void __attribute__((export_name("TS_ChannelSigner_free"))) TS_ChannelSigner_free(uint64_t this_ptr) {
26560 if (!ptr_is_owned(this_ptr)) return;
26561 void* this_ptr_ptr = untag_ptr(this_ptr);
26562 CHECK_ACCESS(this_ptr_ptr);
26563 LDKChannelSigner this_ptr_conv = *(LDKChannelSigner*)(this_ptr_ptr);
26564 FREE(untag_ptr(this_ptr));
26565 ChannelSigner_free(this_ptr_conv);
26568 void __attribute__((export_name("TS_EcdsaChannelSigner_free"))) TS_EcdsaChannelSigner_free(uint64_t this_ptr) {
26569 if (!ptr_is_owned(this_ptr)) return;
26570 void* this_ptr_ptr = untag_ptr(this_ptr);
26571 CHECK_ACCESS(this_ptr_ptr);
26572 LDKEcdsaChannelSigner this_ptr_conv = *(LDKEcdsaChannelSigner*)(this_ptr_ptr);
26573 FREE(untag_ptr(this_ptr));
26574 EcdsaChannelSigner_free(this_ptr_conv);
26577 static inline uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg) {
26578 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
26579 *ret_ret = WriteableEcdsaChannelSigner_clone(arg);
26580 return tag_ptr(ret_ret, true);
26582 int64_t __attribute__((export_name("TS_WriteableEcdsaChannelSigner_clone_ptr"))) TS_WriteableEcdsaChannelSigner_clone_ptr(uint64_t arg) {
26583 void* arg_ptr = untag_ptr(arg);
26584 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
26585 LDKWriteableEcdsaChannelSigner* arg_conv = (LDKWriteableEcdsaChannelSigner*)arg_ptr;
26586 int64_t ret_conv = WriteableEcdsaChannelSigner_clone_ptr(arg_conv);
26590 uint64_t __attribute__((export_name("TS_WriteableEcdsaChannelSigner_clone"))) TS_WriteableEcdsaChannelSigner_clone(uint64_t orig) {
26591 void* orig_ptr = untag_ptr(orig);
26592 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
26593 LDKWriteableEcdsaChannelSigner* orig_conv = (LDKWriteableEcdsaChannelSigner*)orig_ptr;
26594 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
26595 *ret_ret = WriteableEcdsaChannelSigner_clone(orig_conv);
26596 return tag_ptr(ret_ret, true);
26599 void __attribute__((export_name("TS_WriteableEcdsaChannelSigner_free"))) TS_WriteableEcdsaChannelSigner_free(uint64_t this_ptr) {
26600 if (!ptr_is_owned(this_ptr)) return;
26601 void* this_ptr_ptr = untag_ptr(this_ptr);
26602 CHECK_ACCESS(this_ptr_ptr);
26603 LDKWriteableEcdsaChannelSigner this_ptr_conv = *(LDKWriteableEcdsaChannelSigner*)(this_ptr_ptr);
26604 FREE(untag_ptr(this_ptr));
26605 WriteableEcdsaChannelSigner_free(this_ptr_conv);
26608 uint32_t __attribute__((export_name("TS_Recipient_clone"))) TS_Recipient_clone(uint64_t orig) {
26609 LDKRecipient* orig_conv = (LDKRecipient*)untag_ptr(orig);
26610 uint32_t ret_conv = LDKRecipient_to_js(Recipient_clone(orig_conv));
26614 uint32_t __attribute__((export_name("TS_Recipient_node"))) TS_Recipient_node() {
26615 uint32_t ret_conv = LDKRecipient_to_js(Recipient_node());
26619 uint32_t __attribute__((export_name("TS_Recipient_phantom_node"))) TS_Recipient_phantom_node() {
26620 uint32_t ret_conv = LDKRecipient_to_js(Recipient_phantom_node());
26624 void __attribute__((export_name("TS_EntropySource_free"))) TS_EntropySource_free(uint64_t this_ptr) {
26625 if (!ptr_is_owned(this_ptr)) return;
26626 void* this_ptr_ptr = untag_ptr(this_ptr);
26627 CHECK_ACCESS(this_ptr_ptr);
26628 LDKEntropySource this_ptr_conv = *(LDKEntropySource*)(this_ptr_ptr);
26629 FREE(untag_ptr(this_ptr));
26630 EntropySource_free(this_ptr_conv);
26633 void __attribute__((export_name("TS_NodeSigner_free"))) TS_NodeSigner_free(uint64_t this_ptr) {
26634 if (!ptr_is_owned(this_ptr)) return;
26635 void* this_ptr_ptr = untag_ptr(this_ptr);
26636 CHECK_ACCESS(this_ptr_ptr);
26637 LDKNodeSigner this_ptr_conv = *(LDKNodeSigner*)(this_ptr_ptr);
26638 FREE(untag_ptr(this_ptr));
26639 NodeSigner_free(this_ptr_conv);
26642 void __attribute__((export_name("TS_SignerProvider_free"))) TS_SignerProvider_free(uint64_t this_ptr) {
26643 if (!ptr_is_owned(this_ptr)) return;
26644 void* this_ptr_ptr = untag_ptr(this_ptr);
26645 CHECK_ACCESS(this_ptr_ptr);
26646 LDKSignerProvider this_ptr_conv = *(LDKSignerProvider*)(this_ptr_ptr);
26647 FREE(untag_ptr(this_ptr));
26648 SignerProvider_free(this_ptr_conv);
26651 void __attribute__((export_name("TS_InMemorySigner_free"))) TS_InMemorySigner_free(uint64_t this_obj) {
26652 LDKInMemorySigner this_obj_conv;
26653 this_obj_conv.inner = untag_ptr(this_obj);
26654 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26656 InMemorySigner_free(this_obj_conv);
26659 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_funding_key"))) TS_InMemorySigner_get_funding_key(uint64_t this_ptr) {
26660 LDKInMemorySigner this_ptr_conv;
26661 this_ptr_conv.inner = untag_ptr(this_ptr);
26662 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26664 this_ptr_conv.is_owned = false;
26665 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26666 memcpy(ret_arr->elems, *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
26670 void __attribute__((export_name("TS_InMemorySigner_set_funding_key"))) TS_InMemorySigner_set_funding_key(uint64_t this_ptr, int8_tArray val) {
26671 LDKInMemorySigner this_ptr_conv;
26672 this_ptr_conv.inner = untag_ptr(this_ptr);
26673 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26675 this_ptr_conv.is_owned = false;
26676 LDKSecretKey val_ref;
26677 CHECK(val->arr_len == 32);
26678 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26679 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
26682 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_revocation_base_key"))) TS_InMemorySigner_get_revocation_base_key(uint64_t this_ptr) {
26683 LDKInMemorySigner this_ptr_conv;
26684 this_ptr_conv.inner = untag_ptr(this_ptr);
26685 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26686 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26687 this_ptr_conv.is_owned = false;
26688 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26689 memcpy(ret_arr->elems, *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
26693 void __attribute__((export_name("TS_InMemorySigner_set_revocation_base_key"))) TS_InMemorySigner_set_revocation_base_key(uint64_t this_ptr, int8_tArray val) {
26694 LDKInMemorySigner this_ptr_conv;
26695 this_ptr_conv.inner = untag_ptr(this_ptr);
26696 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26698 this_ptr_conv.is_owned = false;
26699 LDKSecretKey val_ref;
26700 CHECK(val->arr_len == 32);
26701 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26702 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
26705 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_payment_key"))) TS_InMemorySigner_get_payment_key(uint64_t this_ptr) {
26706 LDKInMemorySigner this_ptr_conv;
26707 this_ptr_conv.inner = untag_ptr(this_ptr);
26708 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26710 this_ptr_conv.is_owned = false;
26711 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26712 memcpy(ret_arr->elems, *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
26716 void __attribute__((export_name("TS_InMemorySigner_set_payment_key"))) TS_InMemorySigner_set_payment_key(uint64_t this_ptr, int8_tArray val) {
26717 LDKInMemorySigner this_ptr_conv;
26718 this_ptr_conv.inner = untag_ptr(this_ptr);
26719 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26721 this_ptr_conv.is_owned = false;
26722 LDKSecretKey val_ref;
26723 CHECK(val->arr_len == 32);
26724 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26725 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
26728 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_delayed_payment_base_key"))) TS_InMemorySigner_get_delayed_payment_base_key(uint64_t this_ptr) {
26729 LDKInMemorySigner this_ptr_conv;
26730 this_ptr_conv.inner = untag_ptr(this_ptr);
26731 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26733 this_ptr_conv.is_owned = false;
26734 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26735 memcpy(ret_arr->elems, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
26739 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) {
26740 LDKInMemorySigner this_ptr_conv;
26741 this_ptr_conv.inner = untag_ptr(this_ptr);
26742 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26744 this_ptr_conv.is_owned = false;
26745 LDKSecretKey val_ref;
26746 CHECK(val->arr_len == 32);
26747 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26748 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
26751 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_htlc_base_key"))) TS_InMemorySigner_get_htlc_base_key(uint64_t this_ptr) {
26752 LDKInMemorySigner this_ptr_conv;
26753 this_ptr_conv.inner = untag_ptr(this_ptr);
26754 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26755 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26756 this_ptr_conv.is_owned = false;
26757 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26758 memcpy(ret_arr->elems, *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
26762 void __attribute__((export_name("TS_InMemorySigner_set_htlc_base_key"))) TS_InMemorySigner_set_htlc_base_key(uint64_t this_ptr, int8_tArray val) {
26763 LDKInMemorySigner this_ptr_conv;
26764 this_ptr_conv.inner = untag_ptr(this_ptr);
26765 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26767 this_ptr_conv.is_owned = false;
26768 LDKSecretKey val_ref;
26769 CHECK(val->arr_len == 32);
26770 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26771 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
26774 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_commitment_seed"))) TS_InMemorySigner_get_commitment_seed(uint64_t this_ptr) {
26775 LDKInMemorySigner this_ptr_conv;
26776 this_ptr_conv.inner = untag_ptr(this_ptr);
26777 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26779 this_ptr_conv.is_owned = false;
26780 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26781 memcpy(ret_arr->elems, *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
26785 void __attribute__((export_name("TS_InMemorySigner_set_commitment_seed"))) TS_InMemorySigner_set_commitment_seed(uint64_t this_ptr, int8_tArray val) {
26786 LDKInMemorySigner this_ptr_conv;
26787 this_ptr_conv.inner = untag_ptr(this_ptr);
26788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26790 this_ptr_conv.is_owned = false;
26791 LDKThirtyTwoBytes val_ref;
26792 CHECK(val->arr_len == 32);
26793 memcpy(val_ref.data, val->elems, 32); FREE(val);
26794 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
26797 static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
26798 LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
26799 uint64_t ret_ref = 0;
26800 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26801 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26804 int64_t __attribute__((export_name("TS_InMemorySigner_clone_ptr"))) TS_InMemorySigner_clone_ptr(uint64_t arg) {
26805 LDKInMemorySigner arg_conv;
26806 arg_conv.inner = untag_ptr(arg);
26807 arg_conv.is_owned = ptr_is_owned(arg);
26808 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26809 arg_conv.is_owned = false;
26810 int64_t ret_conv = InMemorySigner_clone_ptr(&arg_conv);
26814 uint64_t __attribute__((export_name("TS_InMemorySigner_clone"))) TS_InMemorySigner_clone(uint64_t orig) {
26815 LDKInMemorySigner orig_conv;
26816 orig_conv.inner = untag_ptr(orig);
26817 orig_conv.is_owned = ptr_is_owned(orig);
26818 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26819 orig_conv.is_owned = false;
26820 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
26821 uint64_t ret_ref = 0;
26822 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26823 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26827 uint64_t __attribute__((export_name("TS_InMemorySigner_new"))) TS_InMemorySigner_new(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, int8_tArray rand_bytes_unique_start) {
26828 LDKSecretKey funding_key_ref;
26829 CHECK(funding_key->arr_len == 32);
26830 memcpy(funding_key_ref.bytes, funding_key->elems, 32); FREE(funding_key);
26831 LDKSecretKey revocation_base_key_ref;
26832 CHECK(revocation_base_key->arr_len == 32);
26833 memcpy(revocation_base_key_ref.bytes, revocation_base_key->elems, 32); FREE(revocation_base_key);
26834 LDKSecretKey payment_key_ref;
26835 CHECK(payment_key->arr_len == 32);
26836 memcpy(payment_key_ref.bytes, payment_key->elems, 32); FREE(payment_key);
26837 LDKSecretKey delayed_payment_base_key_ref;
26838 CHECK(delayed_payment_base_key->arr_len == 32);
26839 memcpy(delayed_payment_base_key_ref.bytes, delayed_payment_base_key->elems, 32); FREE(delayed_payment_base_key);
26840 LDKSecretKey htlc_base_key_ref;
26841 CHECK(htlc_base_key->arr_len == 32);
26842 memcpy(htlc_base_key_ref.bytes, htlc_base_key->elems, 32); FREE(htlc_base_key);
26843 LDKThirtyTwoBytes commitment_seed_ref;
26844 CHECK(commitment_seed->arr_len == 32);
26845 memcpy(commitment_seed_ref.data, commitment_seed->elems, 32); FREE(commitment_seed);
26846 LDKThirtyTwoBytes channel_keys_id_ref;
26847 CHECK(channel_keys_id->arr_len == 32);
26848 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
26849 LDKThirtyTwoBytes rand_bytes_unique_start_ref;
26850 CHECK(rand_bytes_unique_start->arr_len == 32);
26851 memcpy(rand_bytes_unique_start_ref.data, rand_bytes_unique_start->elems, 32); FREE(rand_bytes_unique_start);
26852 LDKInMemorySigner ret_var = InMemorySigner_new(funding_key_ref, revocation_base_key_ref, payment_key_ref, delayed_payment_base_key_ref, htlc_base_key_ref, commitment_seed_ref, channel_value_satoshis, channel_keys_id_ref, rand_bytes_unique_start_ref);
26853 uint64_t ret_ref = 0;
26854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26855 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26859 uint64_t __attribute__((export_name("TS_InMemorySigner_counterparty_pubkeys"))) TS_InMemorySigner_counterparty_pubkeys(uint64_t this_arg) {
26860 LDKInMemorySigner this_arg_conv;
26861 this_arg_conv.inner = untag_ptr(this_arg);
26862 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26863 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26864 this_arg_conv.is_owned = false;
26865 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
26866 uint64_t ret_ref = 0;
26867 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26868 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26872 int16_t __attribute__((export_name("TS_InMemorySigner_counterparty_selected_contest_delay"))) TS_InMemorySigner_counterparty_selected_contest_delay(uint64_t this_arg) {
26873 LDKInMemorySigner this_arg_conv;
26874 this_arg_conv.inner = untag_ptr(this_arg);
26875 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26877 this_arg_conv.is_owned = false;
26878 int16_t ret_conv = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
26882 int16_t __attribute__((export_name("TS_InMemorySigner_holder_selected_contest_delay"))) TS_InMemorySigner_holder_selected_contest_delay(uint64_t this_arg) {
26883 LDKInMemorySigner this_arg_conv;
26884 this_arg_conv.inner = untag_ptr(this_arg);
26885 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26887 this_arg_conv.is_owned = false;
26888 int16_t ret_conv = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
26892 jboolean __attribute__((export_name("TS_InMemorySigner_is_outbound"))) TS_InMemorySigner_is_outbound(uint64_t this_arg) {
26893 LDKInMemorySigner this_arg_conv;
26894 this_arg_conv.inner = untag_ptr(this_arg);
26895 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26897 this_arg_conv.is_owned = false;
26898 jboolean ret_conv = InMemorySigner_is_outbound(&this_arg_conv);
26902 uint64_t __attribute__((export_name("TS_InMemorySigner_funding_outpoint"))) TS_InMemorySigner_funding_outpoint(uint64_t this_arg) {
26903 LDKInMemorySigner this_arg_conv;
26904 this_arg_conv.inner = untag_ptr(this_arg);
26905 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26907 this_arg_conv.is_owned = false;
26908 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
26909 uint64_t ret_ref = 0;
26910 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26911 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26915 uint64_t __attribute__((export_name("TS_InMemorySigner_get_channel_parameters"))) TS_InMemorySigner_get_channel_parameters(uint64_t this_arg) {
26916 LDKInMemorySigner this_arg_conv;
26917 this_arg_conv.inner = untag_ptr(this_arg);
26918 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26920 this_arg_conv.is_owned = false;
26921 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
26922 uint64_t ret_ref = 0;
26923 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26924 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26928 jboolean __attribute__((export_name("TS_InMemorySigner_opt_anchors"))) TS_InMemorySigner_opt_anchors(uint64_t this_arg) {
26929 LDKInMemorySigner this_arg_conv;
26930 this_arg_conv.inner = untag_ptr(this_arg);
26931 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26933 this_arg_conv.is_owned = false;
26934 jboolean ret_conv = InMemorySigner_opt_anchors(&this_arg_conv);
26938 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) {
26939 LDKInMemorySigner this_arg_conv;
26940 this_arg_conv.inner = untag_ptr(this_arg);
26941 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26942 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26943 this_arg_conv.is_owned = false;
26944 LDKTransaction spend_tx_ref;
26945 spend_tx_ref.datalen = spend_tx->arr_len;
26946 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
26947 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
26948 spend_tx_ref.data_is_owned = true;
26949 LDKStaticPaymentOutputDescriptor descriptor_conv;
26950 descriptor_conv.inner = untag_ptr(descriptor);
26951 descriptor_conv.is_owned = ptr_is_owned(descriptor);
26952 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
26953 descriptor_conv.is_owned = false;
26954 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
26955 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
26956 return tag_ptr(ret_conv, true);
26959 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) {
26960 LDKInMemorySigner this_arg_conv;
26961 this_arg_conv.inner = untag_ptr(this_arg);
26962 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26964 this_arg_conv.is_owned = false;
26965 LDKTransaction spend_tx_ref;
26966 spend_tx_ref.datalen = spend_tx->arr_len;
26967 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
26968 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
26969 spend_tx_ref.data_is_owned = true;
26970 LDKDelayedPaymentOutputDescriptor descriptor_conv;
26971 descriptor_conv.inner = untag_ptr(descriptor);
26972 descriptor_conv.is_owned = ptr_is_owned(descriptor);
26973 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
26974 descriptor_conv.is_owned = false;
26975 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
26976 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
26977 return tag_ptr(ret_conv, true);
26980 uint64_t __attribute__((export_name("TS_InMemorySigner_as_EntropySource"))) TS_InMemorySigner_as_EntropySource(uint64_t this_arg) {
26981 LDKInMemorySigner this_arg_conv;
26982 this_arg_conv.inner = untag_ptr(this_arg);
26983 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26985 this_arg_conv.is_owned = false;
26986 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
26987 *ret_ret = InMemorySigner_as_EntropySource(&this_arg_conv);
26988 return tag_ptr(ret_ret, true);
26991 uint64_t __attribute__((export_name("TS_InMemorySigner_as_ChannelSigner"))) TS_InMemorySigner_as_ChannelSigner(uint64_t this_arg) {
26992 LDKInMemorySigner this_arg_conv;
26993 this_arg_conv.inner = untag_ptr(this_arg);
26994 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26995 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26996 this_arg_conv.is_owned = false;
26997 LDKChannelSigner* ret_ret = MALLOC(sizeof(LDKChannelSigner), "LDKChannelSigner");
26998 *ret_ret = InMemorySigner_as_ChannelSigner(&this_arg_conv);
26999 return tag_ptr(ret_ret, true);
27002 uint64_t __attribute__((export_name("TS_InMemorySigner_as_EcdsaChannelSigner"))) TS_InMemorySigner_as_EcdsaChannelSigner(uint64_t this_arg) {
27003 LDKInMemorySigner this_arg_conv;
27004 this_arg_conv.inner = untag_ptr(this_arg);
27005 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27006 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27007 this_arg_conv.is_owned = false;
27008 LDKEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKEcdsaChannelSigner), "LDKEcdsaChannelSigner");
27009 *ret_ret = InMemorySigner_as_EcdsaChannelSigner(&this_arg_conv);
27010 return tag_ptr(ret_ret, true);
27013 uint64_t __attribute__((export_name("TS_InMemorySigner_as_WriteableEcdsaChannelSigner"))) TS_InMemorySigner_as_WriteableEcdsaChannelSigner(uint64_t this_arg) {
27014 LDKInMemorySigner this_arg_conv;
27015 this_arg_conv.inner = untag_ptr(this_arg);
27016 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27018 this_arg_conv.is_owned = false;
27019 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
27020 *ret_ret = InMemorySigner_as_WriteableEcdsaChannelSigner(&this_arg_conv);
27021 return tag_ptr(ret_ret, true);
27024 int8_tArray __attribute__((export_name("TS_InMemorySigner_write"))) TS_InMemorySigner_write(uint64_t obj) {
27025 LDKInMemorySigner obj_conv;
27026 obj_conv.inner = untag_ptr(obj);
27027 obj_conv.is_owned = ptr_is_owned(obj);
27028 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27029 obj_conv.is_owned = false;
27030 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
27031 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27032 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27033 CVec_u8Z_free(ret_var);
27037 uint64_t __attribute__((export_name("TS_InMemorySigner_read"))) TS_InMemorySigner_read(int8_tArray ser, uint64_t arg) {
27038 LDKu8slice ser_ref;
27039 ser_ref.datalen = ser->arr_len;
27040 ser_ref.data = ser->elems;
27041 void* arg_ptr = untag_ptr(arg);
27042 CHECK_ACCESS(arg_ptr);
27043 LDKEntropySource arg_conv = *(LDKEntropySource*)(arg_ptr);
27044 if (arg_conv.free == LDKEntropySource_JCalls_free) {
27045 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27046 LDKEntropySource_JCalls_cloned(&arg_conv);
27048 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
27049 *ret_conv = InMemorySigner_read(ser_ref, arg_conv);
27051 return tag_ptr(ret_conv, true);
27054 void __attribute__((export_name("TS_KeysManager_free"))) TS_KeysManager_free(uint64_t this_obj) {
27055 LDKKeysManager 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 KeysManager_free(this_obj_conv);
27062 uint64_t __attribute__((export_name("TS_KeysManager_new"))) TS_KeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
27063 uint8_t seed_arr[32];
27064 CHECK(seed->arr_len == 32);
27065 memcpy(seed_arr, seed->elems, 32); FREE(seed);
27066 uint8_t (*seed_ref)[32] = &seed_arr;
27067 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
27068 uint64_t ret_ref = 0;
27069 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27070 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27074 int8_tArray __attribute__((export_name("TS_KeysManager_get_node_secret_key"))) TS_KeysManager_get_node_secret_key(uint64_t this_arg) {
27075 LDKKeysManager this_arg_conv;
27076 this_arg_conv.inner = untag_ptr(this_arg);
27077 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27078 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27079 this_arg_conv.is_owned = false;
27080 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27081 memcpy(ret_arr->elems, KeysManager_get_node_secret_key(&this_arg_conv).bytes, 32);
27085 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) {
27086 LDKKeysManager this_arg_conv;
27087 this_arg_conv.inner = untag_ptr(this_arg);
27088 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27090 this_arg_conv.is_owned = false;
27091 uint8_t params_arr[32];
27092 CHECK(params->arr_len == 32);
27093 memcpy(params_arr, params->elems, 32); FREE(params);
27094 uint8_t (*params_ref)[32] = ¶ms_arr;
27095 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
27096 uint64_t ret_ref = 0;
27097 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27098 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27102 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) {
27103 LDKKeysManager this_arg_conv;
27104 this_arg_conv.inner = untag_ptr(this_arg);
27105 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27106 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27107 this_arg_conv.is_owned = false;
27108 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
27109 descriptors_constr.datalen = descriptors->arr_len;
27110 if (descriptors_constr.datalen > 0)
27111 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
27113 descriptors_constr.data = NULL;
27114 uint64_t* descriptors_vals = descriptors->elems;
27115 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
27116 uint64_t descriptors_conv_27 = descriptors_vals[b];
27117 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
27118 CHECK_ACCESS(descriptors_conv_27_ptr);
27119 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
27120 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
27121 descriptors_constr.data[b] = descriptors_conv_27_conv;
27124 LDKCVec_TxOutZ outputs_constr;
27125 outputs_constr.datalen = outputs->arr_len;
27126 if (outputs_constr.datalen > 0)
27127 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
27129 outputs_constr.data = NULL;
27130 uint64_t* outputs_vals = outputs->elems;
27131 for (size_t h = 0; h < outputs_constr.datalen; h++) {
27132 uint64_t outputs_conv_7 = outputs_vals[h];
27133 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
27134 CHECK_ACCESS(outputs_conv_7_ptr);
27135 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
27136 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
27137 outputs_constr.data[h] = outputs_conv_7_conv;
27140 LDKCVec_u8Z change_destination_script_ref;
27141 change_destination_script_ref.datalen = change_destination_script->arr_len;
27142 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
27143 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
27144 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
27145 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
27146 return tag_ptr(ret_conv, true);
27149 uint64_t __attribute__((export_name("TS_KeysManager_as_EntropySource"))) TS_KeysManager_as_EntropySource(uint64_t this_arg) {
27150 LDKKeysManager this_arg_conv;
27151 this_arg_conv.inner = untag_ptr(this_arg);
27152 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27154 this_arg_conv.is_owned = false;
27155 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
27156 *ret_ret = KeysManager_as_EntropySource(&this_arg_conv);
27157 return tag_ptr(ret_ret, true);
27160 uint64_t __attribute__((export_name("TS_KeysManager_as_NodeSigner"))) TS_KeysManager_as_NodeSigner(uint64_t this_arg) {
27161 LDKKeysManager this_arg_conv;
27162 this_arg_conv.inner = untag_ptr(this_arg);
27163 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27164 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27165 this_arg_conv.is_owned = false;
27166 LDKNodeSigner* ret_ret = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
27167 *ret_ret = KeysManager_as_NodeSigner(&this_arg_conv);
27168 return tag_ptr(ret_ret, true);
27171 uint64_t __attribute__((export_name("TS_KeysManager_as_SignerProvider"))) TS_KeysManager_as_SignerProvider(uint64_t this_arg) {
27172 LDKKeysManager this_arg_conv;
27173 this_arg_conv.inner = untag_ptr(this_arg);
27174 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27175 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27176 this_arg_conv.is_owned = false;
27177 LDKSignerProvider* ret_ret = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
27178 *ret_ret = KeysManager_as_SignerProvider(&this_arg_conv);
27179 return tag_ptr(ret_ret, true);
27182 void __attribute__((export_name("TS_PhantomKeysManager_free"))) TS_PhantomKeysManager_free(uint64_t this_obj) {
27183 LDKPhantomKeysManager this_obj_conv;
27184 this_obj_conv.inner = untag_ptr(this_obj);
27185 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27187 PhantomKeysManager_free(this_obj_conv);
27190 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_EntropySource"))) TS_PhantomKeysManager_as_EntropySource(uint64_t this_arg) {
27191 LDKPhantomKeysManager this_arg_conv;
27192 this_arg_conv.inner = untag_ptr(this_arg);
27193 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27194 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27195 this_arg_conv.is_owned = false;
27196 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
27197 *ret_ret = PhantomKeysManager_as_EntropySource(&this_arg_conv);
27198 return tag_ptr(ret_ret, true);
27201 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_NodeSigner"))) TS_PhantomKeysManager_as_NodeSigner(uint64_t this_arg) {
27202 LDKPhantomKeysManager this_arg_conv;
27203 this_arg_conv.inner = untag_ptr(this_arg);
27204 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27206 this_arg_conv.is_owned = false;
27207 LDKNodeSigner* ret_ret = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
27208 *ret_ret = PhantomKeysManager_as_NodeSigner(&this_arg_conv);
27209 return tag_ptr(ret_ret, true);
27212 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_SignerProvider"))) TS_PhantomKeysManager_as_SignerProvider(uint64_t this_arg) {
27213 LDKPhantomKeysManager this_arg_conv;
27214 this_arg_conv.inner = untag_ptr(this_arg);
27215 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27217 this_arg_conv.is_owned = false;
27218 LDKSignerProvider* ret_ret = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
27219 *ret_ret = PhantomKeysManager_as_SignerProvider(&this_arg_conv);
27220 return tag_ptr(ret_ret, true);
27223 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) {
27224 uint8_t seed_arr[32];
27225 CHECK(seed->arr_len == 32);
27226 memcpy(seed_arr, seed->elems, 32); FREE(seed);
27227 uint8_t (*seed_ref)[32] = &seed_arr;
27228 uint8_t cross_node_seed_arr[32];
27229 CHECK(cross_node_seed->arr_len == 32);
27230 memcpy(cross_node_seed_arr, cross_node_seed->elems, 32); FREE(cross_node_seed);
27231 uint8_t (*cross_node_seed_ref)[32] = &cross_node_seed_arr;
27232 LDKPhantomKeysManager ret_var = PhantomKeysManager_new(seed_ref, starting_time_secs, starting_time_nanos, cross_node_seed_ref);
27233 uint64_t ret_ref = 0;
27234 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27235 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27239 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) {
27240 LDKPhantomKeysManager this_arg_conv;
27241 this_arg_conv.inner = untag_ptr(this_arg);
27242 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27244 this_arg_conv.is_owned = false;
27245 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
27246 descriptors_constr.datalen = descriptors->arr_len;
27247 if (descriptors_constr.datalen > 0)
27248 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
27250 descriptors_constr.data = NULL;
27251 uint64_t* descriptors_vals = descriptors->elems;
27252 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
27253 uint64_t descriptors_conv_27 = descriptors_vals[b];
27254 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
27255 CHECK_ACCESS(descriptors_conv_27_ptr);
27256 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
27257 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
27258 descriptors_constr.data[b] = descriptors_conv_27_conv;
27261 LDKCVec_TxOutZ outputs_constr;
27262 outputs_constr.datalen = outputs->arr_len;
27263 if (outputs_constr.datalen > 0)
27264 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
27266 outputs_constr.data = NULL;
27267 uint64_t* outputs_vals = outputs->elems;
27268 for (size_t h = 0; h < outputs_constr.datalen; h++) {
27269 uint64_t outputs_conv_7 = outputs_vals[h];
27270 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
27271 CHECK_ACCESS(outputs_conv_7_ptr);
27272 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
27273 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
27274 outputs_constr.data[h] = outputs_conv_7_conv;
27277 LDKCVec_u8Z change_destination_script_ref;
27278 change_destination_script_ref.datalen = change_destination_script->arr_len;
27279 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
27280 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
27281 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
27282 *ret_conv = PhantomKeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
27283 return tag_ptr(ret_conv, true);
27286 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) {
27287 LDKPhantomKeysManager this_arg_conv;
27288 this_arg_conv.inner = untag_ptr(this_arg);
27289 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27291 this_arg_conv.is_owned = false;
27292 uint8_t params_arr[32];
27293 CHECK(params->arr_len == 32);
27294 memcpy(params_arr, params->elems, 32); FREE(params);
27295 uint8_t (*params_ref)[32] = ¶ms_arr;
27296 LDKInMemorySigner ret_var = PhantomKeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
27297 uint64_t ret_ref = 0;
27298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27303 int8_tArray __attribute__((export_name("TS_PhantomKeysManager_get_node_secret_key"))) TS_PhantomKeysManager_get_node_secret_key(uint64_t this_arg) {
27304 LDKPhantomKeysManager this_arg_conv;
27305 this_arg_conv.inner = untag_ptr(this_arg);
27306 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27308 this_arg_conv.is_owned = false;
27309 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27310 memcpy(ret_arr->elems, PhantomKeysManager_get_node_secret_key(&this_arg_conv).bytes, 32);
27314 int8_tArray __attribute__((export_name("TS_PhantomKeysManager_get_phantom_node_secret_key"))) TS_PhantomKeysManager_get_phantom_node_secret_key(uint64_t this_arg) {
27315 LDKPhantomKeysManager this_arg_conv;
27316 this_arg_conv.inner = untag_ptr(this_arg);
27317 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27318 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27319 this_arg_conv.is_owned = false;
27320 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27321 memcpy(ret_arr->elems, PhantomKeysManager_get_phantom_node_secret_key(&this_arg_conv).bytes, 32);
27325 uint32_t __attribute__((export_name("TS_FailureCode_clone"))) TS_FailureCode_clone(uint64_t orig) {
27326 LDKFailureCode* orig_conv = (LDKFailureCode*)untag_ptr(orig);
27327 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_clone(orig_conv));
27331 uint32_t __attribute__((export_name("TS_FailureCode_temporary_node_failure"))) TS_FailureCode_temporary_node_failure() {
27332 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_temporary_node_failure());
27336 uint32_t __attribute__((export_name("TS_FailureCode_required_node_feature_missing"))) TS_FailureCode_required_node_feature_missing() {
27337 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_required_node_feature_missing());
27341 uint32_t __attribute__((export_name("TS_FailureCode_incorrect_or_unknown_payment_details"))) TS_FailureCode_incorrect_or_unknown_payment_details() {
27342 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_incorrect_or_unknown_payment_details());
27346 void __attribute__((export_name("TS_ChannelManager_free"))) TS_ChannelManager_free(uint64_t this_obj) {
27347 LDKChannelManager this_obj_conv;
27348 this_obj_conv.inner = untag_ptr(this_obj);
27349 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27350 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27351 ChannelManager_free(this_obj_conv);
27354 void __attribute__((export_name("TS_ChainParameters_free"))) TS_ChainParameters_free(uint64_t this_obj) {
27355 LDKChainParameters this_obj_conv;
27356 this_obj_conv.inner = untag_ptr(this_obj);
27357 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27359 ChainParameters_free(this_obj_conv);
27362 uint32_t __attribute__((export_name("TS_ChainParameters_get_network"))) TS_ChainParameters_get_network(uint64_t this_ptr) {
27363 LDKChainParameters this_ptr_conv;
27364 this_ptr_conv.inner = untag_ptr(this_ptr);
27365 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27367 this_ptr_conv.is_owned = false;
27368 uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
27372 void __attribute__((export_name("TS_ChainParameters_set_network"))) TS_ChainParameters_set_network(uint64_t this_ptr, uint32_t val) {
27373 LDKChainParameters this_ptr_conv;
27374 this_ptr_conv.inner = untag_ptr(this_ptr);
27375 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27377 this_ptr_conv.is_owned = false;
27378 LDKNetwork val_conv = LDKNetwork_from_js(val);
27379 ChainParameters_set_network(&this_ptr_conv, val_conv);
27382 uint64_t __attribute__((export_name("TS_ChainParameters_get_best_block"))) TS_ChainParameters_get_best_block(uint64_t this_ptr) {
27383 LDKChainParameters this_ptr_conv;
27384 this_ptr_conv.inner = untag_ptr(this_ptr);
27385 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27386 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27387 this_ptr_conv.is_owned = false;
27388 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
27389 uint64_t ret_ref = 0;
27390 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27391 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27395 void __attribute__((export_name("TS_ChainParameters_set_best_block"))) TS_ChainParameters_set_best_block(uint64_t this_ptr, uint64_t val) {
27396 LDKChainParameters this_ptr_conv;
27397 this_ptr_conv.inner = untag_ptr(this_ptr);
27398 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27400 this_ptr_conv.is_owned = false;
27401 LDKBestBlock val_conv;
27402 val_conv.inner = untag_ptr(val);
27403 val_conv.is_owned = ptr_is_owned(val);
27404 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27405 val_conv = BestBlock_clone(&val_conv);
27406 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
27409 uint64_t __attribute__((export_name("TS_ChainParameters_new"))) TS_ChainParameters_new(uint32_t network_arg, uint64_t best_block_arg) {
27410 LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
27411 LDKBestBlock best_block_arg_conv;
27412 best_block_arg_conv.inner = untag_ptr(best_block_arg);
27413 best_block_arg_conv.is_owned = ptr_is_owned(best_block_arg);
27414 CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
27415 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
27416 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
27417 uint64_t ret_ref = 0;
27418 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27419 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27423 static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
27424 LDKChainParameters ret_var = ChainParameters_clone(arg);
27425 uint64_t ret_ref = 0;
27426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27430 int64_t __attribute__((export_name("TS_ChainParameters_clone_ptr"))) TS_ChainParameters_clone_ptr(uint64_t arg) {
27431 LDKChainParameters arg_conv;
27432 arg_conv.inner = untag_ptr(arg);
27433 arg_conv.is_owned = ptr_is_owned(arg);
27434 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27435 arg_conv.is_owned = false;
27436 int64_t ret_conv = ChainParameters_clone_ptr(&arg_conv);
27440 uint64_t __attribute__((export_name("TS_ChainParameters_clone"))) TS_ChainParameters_clone(uint64_t orig) {
27441 LDKChainParameters orig_conv;
27442 orig_conv.inner = untag_ptr(orig);
27443 orig_conv.is_owned = ptr_is_owned(orig);
27444 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27445 orig_conv.is_owned = false;
27446 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
27447 uint64_t ret_ref = 0;
27448 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27449 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27453 void __attribute__((export_name("TS_CounterpartyForwardingInfo_free"))) TS_CounterpartyForwardingInfo_free(uint64_t this_obj) {
27454 LDKCounterpartyForwardingInfo this_obj_conv;
27455 this_obj_conv.inner = untag_ptr(this_obj);
27456 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27458 CounterpartyForwardingInfo_free(this_obj_conv);
27461 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_base_msat"))) TS_CounterpartyForwardingInfo_get_fee_base_msat(uint64_t this_ptr) {
27462 LDKCounterpartyForwardingInfo this_ptr_conv;
27463 this_ptr_conv.inner = untag_ptr(this_ptr);
27464 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27466 this_ptr_conv.is_owned = false;
27467 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
27471 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_base_msat"))) TS_CounterpartyForwardingInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
27472 LDKCounterpartyForwardingInfo this_ptr_conv;
27473 this_ptr_conv.inner = untag_ptr(this_ptr);
27474 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27476 this_ptr_conv.is_owned = false;
27477 CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
27480 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
27481 LDKCounterpartyForwardingInfo this_ptr_conv;
27482 this_ptr_conv.inner = untag_ptr(this_ptr);
27483 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27485 this_ptr_conv.is_owned = false;
27486 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
27490 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
27491 LDKCounterpartyForwardingInfo this_ptr_conv;
27492 this_ptr_conv.inner = untag_ptr(this_ptr);
27493 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27495 this_ptr_conv.is_owned = false;
27496 CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
27499 int16_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
27500 LDKCounterpartyForwardingInfo this_ptr_conv;
27501 this_ptr_conv.inner = untag_ptr(this_ptr);
27502 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27504 this_ptr_conv.is_owned = false;
27505 int16_t ret_conv = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
27509 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
27510 LDKCounterpartyForwardingInfo this_ptr_conv;
27511 this_ptr_conv.inner = untag_ptr(this_ptr);
27512 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27514 this_ptr_conv.is_owned = false;
27515 CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
27518 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) {
27519 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
27520 uint64_t ret_ref = 0;
27521 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27522 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27526 static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
27527 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
27528 uint64_t ret_ref = 0;
27529 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27530 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27533 int64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone_ptr"))) TS_CounterpartyForwardingInfo_clone_ptr(uint64_t arg) {
27534 LDKCounterpartyForwardingInfo arg_conv;
27535 arg_conv.inner = untag_ptr(arg);
27536 arg_conv.is_owned = ptr_is_owned(arg);
27537 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27538 arg_conv.is_owned = false;
27539 int64_t ret_conv = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
27543 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone"))) TS_CounterpartyForwardingInfo_clone(uint64_t orig) {
27544 LDKCounterpartyForwardingInfo orig_conv;
27545 orig_conv.inner = untag_ptr(orig);
27546 orig_conv.is_owned = ptr_is_owned(orig);
27547 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27548 orig_conv.is_owned = false;
27549 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
27550 uint64_t ret_ref = 0;
27551 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27552 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27556 void __attribute__((export_name("TS_ChannelCounterparty_free"))) TS_ChannelCounterparty_free(uint64_t this_obj) {
27557 LDKChannelCounterparty this_obj_conv;
27558 this_obj_conv.inner = untag_ptr(this_obj);
27559 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27560 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27561 ChannelCounterparty_free(this_obj_conv);
27564 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_get_node_id"))) TS_ChannelCounterparty_get_node_id(uint64_t this_ptr) {
27565 LDKChannelCounterparty this_ptr_conv;
27566 this_ptr_conv.inner = untag_ptr(this_ptr);
27567 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27569 this_ptr_conv.is_owned = false;
27570 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
27571 memcpy(ret_arr->elems, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
27575 void __attribute__((export_name("TS_ChannelCounterparty_set_node_id"))) TS_ChannelCounterparty_set_node_id(uint64_t this_ptr, int8_tArray val) {
27576 LDKChannelCounterparty this_ptr_conv;
27577 this_ptr_conv.inner = untag_ptr(this_ptr);
27578 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27580 this_ptr_conv.is_owned = false;
27581 LDKPublicKey val_ref;
27582 CHECK(val->arr_len == 33);
27583 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
27584 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
27587 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_features"))) TS_ChannelCounterparty_get_features(uint64_t this_ptr) {
27588 LDKChannelCounterparty this_ptr_conv;
27589 this_ptr_conv.inner = untag_ptr(this_ptr);
27590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27592 this_ptr_conv.is_owned = false;
27593 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
27594 uint64_t ret_ref = 0;
27595 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27596 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27600 void __attribute__((export_name("TS_ChannelCounterparty_set_features"))) TS_ChannelCounterparty_set_features(uint64_t this_ptr, uint64_t val) {
27601 LDKChannelCounterparty this_ptr_conv;
27602 this_ptr_conv.inner = untag_ptr(this_ptr);
27603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27605 this_ptr_conv.is_owned = false;
27606 LDKInitFeatures val_conv;
27607 val_conv.inner = untag_ptr(val);
27608 val_conv.is_owned = ptr_is_owned(val);
27609 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27610 val_conv = InitFeatures_clone(&val_conv);
27611 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
27614 int64_t __attribute__((export_name("TS_ChannelCounterparty_get_unspendable_punishment_reserve"))) TS_ChannelCounterparty_get_unspendable_punishment_reserve(uint64_t this_ptr) {
27615 LDKChannelCounterparty this_ptr_conv;
27616 this_ptr_conv.inner = untag_ptr(this_ptr);
27617 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27618 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27619 this_ptr_conv.is_owned = false;
27620 int64_t ret_conv = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
27624 void __attribute__((export_name("TS_ChannelCounterparty_set_unspendable_punishment_reserve"))) TS_ChannelCounterparty_set_unspendable_punishment_reserve(uint64_t this_ptr, int64_t val) {
27625 LDKChannelCounterparty 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 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
27633 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_forwarding_info"))) TS_ChannelCounterparty_get_forwarding_info(uint64_t this_ptr) {
27634 LDKChannelCounterparty this_ptr_conv;
27635 this_ptr_conv.inner = untag_ptr(this_ptr);
27636 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27637 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27638 this_ptr_conv.is_owned = false;
27639 LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
27640 uint64_t ret_ref = 0;
27641 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27642 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27646 void __attribute__((export_name("TS_ChannelCounterparty_set_forwarding_info"))) TS_ChannelCounterparty_set_forwarding_info(uint64_t this_ptr, uint64_t val) {
27647 LDKChannelCounterparty this_ptr_conv;
27648 this_ptr_conv.inner = untag_ptr(this_ptr);
27649 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27650 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27651 this_ptr_conv.is_owned = false;
27652 LDKCounterpartyForwardingInfo val_conv;
27653 val_conv.inner = untag_ptr(val);
27654 val_conv.is_owned = ptr_is_owned(val);
27655 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27656 val_conv = CounterpartyForwardingInfo_clone(&val_conv);
27657 ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
27660 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(uint64_t this_ptr) {
27661 LDKChannelCounterparty this_ptr_conv;
27662 this_ptr_conv.inner = untag_ptr(this_ptr);
27663 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27664 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27665 this_ptr_conv.is_owned = false;
27666 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27667 *ret_copy = ChannelCounterparty_get_outbound_htlc_minimum_msat(&this_ptr_conv);
27668 uint64_t ret_ref = tag_ptr(ret_copy, true);
27672 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) {
27673 LDKChannelCounterparty 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 void* val_ptr = untag_ptr(val);
27679 CHECK_ACCESS(val_ptr);
27680 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27681 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27682 ChannelCounterparty_set_outbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
27685 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(uint64_t this_ptr) {
27686 LDKChannelCounterparty this_ptr_conv;
27687 this_ptr_conv.inner = untag_ptr(this_ptr);
27688 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27690 this_ptr_conv.is_owned = false;
27691 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27692 *ret_copy = ChannelCounterparty_get_outbound_htlc_maximum_msat(&this_ptr_conv);
27693 uint64_t ret_ref = tag_ptr(ret_copy, true);
27697 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) {
27698 LDKChannelCounterparty this_ptr_conv;
27699 this_ptr_conv.inner = untag_ptr(this_ptr);
27700 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27701 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27702 this_ptr_conv.is_owned = false;
27703 void* val_ptr = untag_ptr(val);
27704 CHECK_ACCESS(val_ptr);
27705 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27706 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27707 ChannelCounterparty_set_outbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
27710 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) {
27711 LDKPublicKey node_id_arg_ref;
27712 CHECK(node_id_arg->arr_len == 33);
27713 memcpy(node_id_arg_ref.compressed_form, node_id_arg->elems, 33); FREE(node_id_arg);
27714 LDKInitFeatures features_arg_conv;
27715 features_arg_conv.inner = untag_ptr(features_arg);
27716 features_arg_conv.is_owned = ptr_is_owned(features_arg);
27717 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
27718 features_arg_conv = InitFeatures_clone(&features_arg_conv);
27719 LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
27720 forwarding_info_arg_conv.inner = untag_ptr(forwarding_info_arg);
27721 forwarding_info_arg_conv.is_owned = ptr_is_owned(forwarding_info_arg);
27722 CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
27723 forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
27724 void* outbound_htlc_minimum_msat_arg_ptr = untag_ptr(outbound_htlc_minimum_msat_arg);
27725 CHECK_ACCESS(outbound_htlc_minimum_msat_arg_ptr);
27726 LDKCOption_u64Z outbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_minimum_msat_arg_ptr);
27727 outbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_minimum_msat_arg));
27728 void* outbound_htlc_maximum_msat_arg_ptr = untag_ptr(outbound_htlc_maximum_msat_arg);
27729 CHECK_ACCESS(outbound_htlc_maximum_msat_arg_ptr);
27730 LDKCOption_u64Z outbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_maximum_msat_arg_ptr);
27731 outbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_maximum_msat_arg));
27732 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);
27733 uint64_t ret_ref = 0;
27734 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27735 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27739 static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
27740 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
27741 uint64_t ret_ref = 0;
27742 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27743 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27746 int64_t __attribute__((export_name("TS_ChannelCounterparty_clone_ptr"))) TS_ChannelCounterparty_clone_ptr(uint64_t arg) {
27747 LDKChannelCounterparty arg_conv;
27748 arg_conv.inner = untag_ptr(arg);
27749 arg_conv.is_owned = ptr_is_owned(arg);
27750 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27751 arg_conv.is_owned = false;
27752 int64_t ret_conv = ChannelCounterparty_clone_ptr(&arg_conv);
27756 uint64_t __attribute__((export_name("TS_ChannelCounterparty_clone"))) TS_ChannelCounterparty_clone(uint64_t orig) {
27757 LDKChannelCounterparty orig_conv;
27758 orig_conv.inner = untag_ptr(orig);
27759 orig_conv.is_owned = ptr_is_owned(orig);
27760 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27761 orig_conv.is_owned = false;
27762 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
27763 uint64_t ret_ref = 0;
27764 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27765 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27769 void __attribute__((export_name("TS_ChannelDetails_free"))) TS_ChannelDetails_free(uint64_t this_obj) {
27770 LDKChannelDetails this_obj_conv;
27771 this_obj_conv.inner = untag_ptr(this_obj);
27772 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27774 ChannelDetails_free(this_obj_conv);
27777 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_channel_id"))) TS_ChannelDetails_get_channel_id(uint64_t this_ptr) {
27778 LDKChannelDetails this_ptr_conv;
27779 this_ptr_conv.inner = untag_ptr(this_ptr);
27780 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27781 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27782 this_ptr_conv.is_owned = false;
27783 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27784 memcpy(ret_arr->elems, *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
27788 void __attribute__((export_name("TS_ChannelDetails_set_channel_id"))) TS_ChannelDetails_set_channel_id(uint64_t this_ptr, int8_tArray val) {
27789 LDKChannelDetails this_ptr_conv;
27790 this_ptr_conv.inner = untag_ptr(this_ptr);
27791 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27792 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27793 this_ptr_conv.is_owned = false;
27794 LDKThirtyTwoBytes val_ref;
27795 CHECK(val->arr_len == 32);
27796 memcpy(val_ref.data, val->elems, 32); FREE(val);
27797 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
27800 uint64_t __attribute__((export_name("TS_ChannelDetails_get_counterparty"))) TS_ChannelDetails_get_counterparty(uint64_t this_ptr) {
27801 LDKChannelDetails this_ptr_conv;
27802 this_ptr_conv.inner = untag_ptr(this_ptr);
27803 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27804 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27805 this_ptr_conv.is_owned = false;
27806 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
27807 uint64_t ret_ref = 0;
27808 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27809 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27813 void __attribute__((export_name("TS_ChannelDetails_set_counterparty"))) TS_ChannelDetails_set_counterparty(uint64_t this_ptr, uint64_t val) {
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 LDKChannelCounterparty val_conv;
27820 val_conv.inner = untag_ptr(val);
27821 val_conv.is_owned = ptr_is_owned(val);
27822 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27823 val_conv = ChannelCounterparty_clone(&val_conv);
27824 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
27827 uint64_t __attribute__((export_name("TS_ChannelDetails_get_funding_txo"))) TS_ChannelDetails_get_funding_txo(uint64_t this_ptr) {
27828 LDKChannelDetails this_ptr_conv;
27829 this_ptr_conv.inner = untag_ptr(this_ptr);
27830 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27832 this_ptr_conv.is_owned = false;
27833 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
27834 uint64_t ret_ref = 0;
27835 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27836 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27840 void __attribute__((export_name("TS_ChannelDetails_set_funding_txo"))) TS_ChannelDetails_set_funding_txo(uint64_t this_ptr, uint64_t val) {
27841 LDKChannelDetails this_ptr_conv;
27842 this_ptr_conv.inner = untag_ptr(this_ptr);
27843 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27844 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27845 this_ptr_conv.is_owned = false;
27846 LDKOutPoint val_conv;
27847 val_conv.inner = untag_ptr(val);
27848 val_conv.is_owned = ptr_is_owned(val);
27849 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27850 val_conv = OutPoint_clone(&val_conv);
27851 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
27854 uint64_t __attribute__((export_name("TS_ChannelDetails_get_channel_type"))) TS_ChannelDetails_get_channel_type(uint64_t this_ptr) {
27855 LDKChannelDetails this_ptr_conv;
27856 this_ptr_conv.inner = untag_ptr(this_ptr);
27857 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27858 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27859 this_ptr_conv.is_owned = false;
27860 LDKChannelTypeFeatures ret_var = ChannelDetails_get_channel_type(&this_ptr_conv);
27861 uint64_t ret_ref = 0;
27862 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27863 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27867 void __attribute__((export_name("TS_ChannelDetails_set_channel_type"))) TS_ChannelDetails_set_channel_type(uint64_t this_ptr, uint64_t val) {
27868 LDKChannelDetails this_ptr_conv;
27869 this_ptr_conv.inner = untag_ptr(this_ptr);
27870 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27872 this_ptr_conv.is_owned = false;
27873 LDKChannelTypeFeatures val_conv;
27874 val_conv.inner = untag_ptr(val);
27875 val_conv.is_owned = ptr_is_owned(val);
27876 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27877 val_conv = ChannelTypeFeatures_clone(&val_conv);
27878 ChannelDetails_set_channel_type(&this_ptr_conv, val_conv);
27881 uint64_t __attribute__((export_name("TS_ChannelDetails_get_short_channel_id"))) TS_ChannelDetails_get_short_channel_id(uint64_t this_ptr) {
27882 LDKChannelDetails this_ptr_conv;
27883 this_ptr_conv.inner = untag_ptr(this_ptr);
27884 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27886 this_ptr_conv.is_owned = false;
27887 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27888 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
27889 uint64_t ret_ref = tag_ptr(ret_copy, true);
27893 void __attribute__((export_name("TS_ChannelDetails_set_short_channel_id"))) TS_ChannelDetails_set_short_channel_id(uint64_t this_ptr, uint64_t val) {
27894 LDKChannelDetails this_ptr_conv;
27895 this_ptr_conv.inner = untag_ptr(this_ptr);
27896 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27898 this_ptr_conv.is_owned = false;
27899 void* val_ptr = untag_ptr(val);
27900 CHECK_ACCESS(val_ptr);
27901 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27902 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27903 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
27906 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_scid_alias"))) TS_ChannelDetails_get_outbound_scid_alias(uint64_t this_ptr) {
27907 LDKChannelDetails this_ptr_conv;
27908 this_ptr_conv.inner = untag_ptr(this_ptr);
27909 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27911 this_ptr_conv.is_owned = false;
27912 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27913 *ret_copy = ChannelDetails_get_outbound_scid_alias(&this_ptr_conv);
27914 uint64_t ret_ref = tag_ptr(ret_copy, true);
27918 void __attribute__((export_name("TS_ChannelDetails_set_outbound_scid_alias"))) TS_ChannelDetails_set_outbound_scid_alias(uint64_t this_ptr, uint64_t val) {
27919 LDKChannelDetails this_ptr_conv;
27920 this_ptr_conv.inner = untag_ptr(this_ptr);
27921 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27922 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27923 this_ptr_conv.is_owned = false;
27924 void* val_ptr = untag_ptr(val);
27925 CHECK_ACCESS(val_ptr);
27926 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27927 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27928 ChannelDetails_set_outbound_scid_alias(&this_ptr_conv, val_conv);
27931 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_scid_alias"))) TS_ChannelDetails_get_inbound_scid_alias(uint64_t this_ptr) {
27932 LDKChannelDetails this_ptr_conv;
27933 this_ptr_conv.inner = untag_ptr(this_ptr);
27934 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27936 this_ptr_conv.is_owned = false;
27937 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27938 *ret_copy = ChannelDetails_get_inbound_scid_alias(&this_ptr_conv);
27939 uint64_t ret_ref = tag_ptr(ret_copy, true);
27943 void __attribute__((export_name("TS_ChannelDetails_set_inbound_scid_alias"))) TS_ChannelDetails_set_inbound_scid_alias(uint64_t this_ptr, uint64_t val) {
27944 LDKChannelDetails this_ptr_conv;
27945 this_ptr_conv.inner = untag_ptr(this_ptr);
27946 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27948 this_ptr_conv.is_owned = false;
27949 void* val_ptr = untag_ptr(val);
27950 CHECK_ACCESS(val_ptr);
27951 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27952 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27953 ChannelDetails_set_inbound_scid_alias(&this_ptr_conv, val_conv);
27956 int64_t __attribute__((export_name("TS_ChannelDetails_get_channel_value_satoshis"))) TS_ChannelDetails_get_channel_value_satoshis(uint64_t this_ptr) {
27957 LDKChannelDetails this_ptr_conv;
27958 this_ptr_conv.inner = untag_ptr(this_ptr);
27959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27961 this_ptr_conv.is_owned = false;
27962 int64_t ret_conv = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
27966 void __attribute__((export_name("TS_ChannelDetails_set_channel_value_satoshis"))) TS_ChannelDetails_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
27967 LDKChannelDetails this_ptr_conv;
27968 this_ptr_conv.inner = untag_ptr(this_ptr);
27969 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27971 this_ptr_conv.is_owned = false;
27972 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
27975 uint64_t __attribute__((export_name("TS_ChannelDetails_get_unspendable_punishment_reserve"))) TS_ChannelDetails_get_unspendable_punishment_reserve(uint64_t this_ptr) {
27976 LDKChannelDetails this_ptr_conv;
27977 this_ptr_conv.inner = untag_ptr(this_ptr);
27978 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27980 this_ptr_conv.is_owned = false;
27981 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27982 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
27983 uint64_t ret_ref = tag_ptr(ret_copy, true);
27987 void __attribute__((export_name("TS_ChannelDetails_set_unspendable_punishment_reserve"))) TS_ChannelDetails_set_unspendable_punishment_reserve(uint64_t this_ptr, uint64_t val) {
27988 LDKChannelDetails this_ptr_conv;
27989 this_ptr_conv.inner = untag_ptr(this_ptr);
27990 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27992 this_ptr_conv.is_owned = false;
27993 void* val_ptr = untag_ptr(val);
27994 CHECK_ACCESS(val_ptr);
27995 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27996 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27997 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
28000 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_user_channel_id"))) TS_ChannelDetails_get_user_channel_id(uint64_t this_ptr) {
28001 LDKChannelDetails this_ptr_conv;
28002 this_ptr_conv.inner = untag_ptr(this_ptr);
28003 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28004 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28005 this_ptr_conv.is_owned = false;
28006 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
28007 memcpy(ret_arr->elems, ChannelDetails_get_user_channel_id(&this_ptr_conv).le_bytes, 16);
28011 void __attribute__((export_name("TS_ChannelDetails_set_user_channel_id"))) TS_ChannelDetails_set_user_channel_id(uint64_t this_ptr, int8_tArray val) {
28012 LDKChannelDetails this_ptr_conv;
28013 this_ptr_conv.inner = untag_ptr(this_ptr);
28014 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28016 this_ptr_conv.is_owned = false;
28018 CHECK(val->arr_len == 16);
28019 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
28020 ChannelDetails_set_user_channel_id(&this_ptr_conv, val_ref);
28023 uint64_t __attribute__((export_name("TS_ChannelDetails_get_feerate_sat_per_1000_weight"))) TS_ChannelDetails_get_feerate_sat_per_1000_weight(uint64_t this_ptr) {
28024 LDKChannelDetails this_ptr_conv;
28025 this_ptr_conv.inner = untag_ptr(this_ptr);
28026 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28028 this_ptr_conv.is_owned = false;
28029 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
28030 *ret_copy = ChannelDetails_get_feerate_sat_per_1000_weight(&this_ptr_conv);
28031 uint64_t ret_ref = tag_ptr(ret_copy, true);
28035 void __attribute__((export_name("TS_ChannelDetails_set_feerate_sat_per_1000_weight"))) TS_ChannelDetails_set_feerate_sat_per_1000_weight(uint64_t this_ptr, uint64_t val) {
28036 LDKChannelDetails this_ptr_conv;
28037 this_ptr_conv.inner = untag_ptr(this_ptr);
28038 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28040 this_ptr_conv.is_owned = false;
28041 void* val_ptr = untag_ptr(val);
28042 CHECK_ACCESS(val_ptr);
28043 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
28044 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
28045 ChannelDetails_set_feerate_sat_per_1000_weight(&this_ptr_conv, val_conv);
28048 int64_t __attribute__((export_name("TS_ChannelDetails_get_balance_msat"))) TS_ChannelDetails_get_balance_msat(uint64_t this_ptr) {
28049 LDKChannelDetails this_ptr_conv;
28050 this_ptr_conv.inner = untag_ptr(this_ptr);
28051 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28053 this_ptr_conv.is_owned = false;
28054 int64_t ret_conv = ChannelDetails_get_balance_msat(&this_ptr_conv);
28058 void __attribute__((export_name("TS_ChannelDetails_set_balance_msat"))) TS_ChannelDetails_set_balance_msat(uint64_t this_ptr, int64_t val) {
28059 LDKChannelDetails this_ptr_conv;
28060 this_ptr_conv.inner = untag_ptr(this_ptr);
28061 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28062 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28063 this_ptr_conv.is_owned = false;
28064 ChannelDetails_set_balance_msat(&this_ptr_conv, val);
28067 int64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_capacity_msat"))) TS_ChannelDetails_get_outbound_capacity_msat(uint64_t this_ptr) {
28068 LDKChannelDetails this_ptr_conv;
28069 this_ptr_conv.inner = untag_ptr(this_ptr);
28070 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28071 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28072 this_ptr_conv.is_owned = false;
28073 int64_t ret_conv = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
28077 void __attribute__((export_name("TS_ChannelDetails_set_outbound_capacity_msat"))) TS_ChannelDetails_set_outbound_capacity_msat(uint64_t this_ptr, int64_t val) {
28078 LDKChannelDetails this_ptr_conv;
28079 this_ptr_conv.inner = untag_ptr(this_ptr);
28080 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28081 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28082 this_ptr_conv.is_owned = false;
28083 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
28086 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) {
28087 LDKChannelDetails this_ptr_conv;
28088 this_ptr_conv.inner = untag_ptr(this_ptr);
28089 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28090 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28091 this_ptr_conv.is_owned = false;
28092 int64_t ret_conv = ChannelDetails_get_next_outbound_htlc_limit_msat(&this_ptr_conv);
28096 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) {
28097 LDKChannelDetails this_ptr_conv;
28098 this_ptr_conv.inner = untag_ptr(this_ptr);
28099 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28101 this_ptr_conv.is_owned = false;
28102 ChannelDetails_set_next_outbound_htlc_limit_msat(&this_ptr_conv, val);
28105 int64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_capacity_msat"))) TS_ChannelDetails_get_inbound_capacity_msat(uint64_t this_ptr) {
28106 LDKChannelDetails this_ptr_conv;
28107 this_ptr_conv.inner = untag_ptr(this_ptr);
28108 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28110 this_ptr_conv.is_owned = false;
28111 int64_t ret_conv = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
28115 void __attribute__((export_name("TS_ChannelDetails_set_inbound_capacity_msat"))) TS_ChannelDetails_set_inbound_capacity_msat(uint64_t this_ptr, int64_t val) {
28116 LDKChannelDetails this_ptr_conv;
28117 this_ptr_conv.inner = untag_ptr(this_ptr);
28118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28120 this_ptr_conv.is_owned = false;
28121 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
28124 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations_required"))) TS_ChannelDetails_get_confirmations_required(uint64_t this_ptr) {
28125 LDKChannelDetails this_ptr_conv;
28126 this_ptr_conv.inner = untag_ptr(this_ptr);
28127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28129 this_ptr_conv.is_owned = false;
28130 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
28131 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
28132 uint64_t ret_ref = tag_ptr(ret_copy, true);
28136 void __attribute__((export_name("TS_ChannelDetails_set_confirmations_required"))) TS_ChannelDetails_set_confirmations_required(uint64_t this_ptr, uint64_t val) {
28137 LDKChannelDetails this_ptr_conv;
28138 this_ptr_conv.inner = untag_ptr(this_ptr);
28139 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28141 this_ptr_conv.is_owned = false;
28142 void* val_ptr = untag_ptr(val);
28143 CHECK_ACCESS(val_ptr);
28144 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
28145 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
28146 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
28149 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations"))) TS_ChannelDetails_get_confirmations(uint64_t this_ptr) {
28150 LDKChannelDetails this_ptr_conv;
28151 this_ptr_conv.inner = untag_ptr(this_ptr);
28152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28154 this_ptr_conv.is_owned = false;
28155 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
28156 *ret_copy = ChannelDetails_get_confirmations(&this_ptr_conv);
28157 uint64_t ret_ref = tag_ptr(ret_copy, true);
28161 void __attribute__((export_name("TS_ChannelDetails_set_confirmations"))) TS_ChannelDetails_set_confirmations(uint64_t this_ptr, uint64_t val) {
28162 LDKChannelDetails this_ptr_conv;
28163 this_ptr_conv.inner = untag_ptr(this_ptr);
28164 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28166 this_ptr_conv.is_owned = false;
28167 void* val_ptr = untag_ptr(val);
28168 CHECK_ACCESS(val_ptr);
28169 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
28170 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
28171 ChannelDetails_set_confirmations(&this_ptr_conv, val_conv);
28174 uint64_t __attribute__((export_name("TS_ChannelDetails_get_force_close_spend_delay"))) TS_ChannelDetails_get_force_close_spend_delay(uint64_t this_ptr) {
28175 LDKChannelDetails this_ptr_conv;
28176 this_ptr_conv.inner = untag_ptr(this_ptr);
28177 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28179 this_ptr_conv.is_owned = false;
28180 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
28181 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
28182 uint64_t ret_ref = tag_ptr(ret_copy, true);
28186 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) {
28187 LDKChannelDetails this_ptr_conv;
28188 this_ptr_conv.inner = untag_ptr(this_ptr);
28189 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28191 this_ptr_conv.is_owned = false;
28192 void* val_ptr = untag_ptr(val);
28193 CHECK_ACCESS(val_ptr);
28194 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
28195 val_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(val));
28196 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
28199 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_outbound"))) TS_ChannelDetails_get_is_outbound(uint64_t this_ptr) {
28200 LDKChannelDetails this_ptr_conv;
28201 this_ptr_conv.inner = untag_ptr(this_ptr);
28202 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28204 this_ptr_conv.is_owned = false;
28205 jboolean ret_conv = ChannelDetails_get_is_outbound(&this_ptr_conv);
28209 void __attribute__((export_name("TS_ChannelDetails_set_is_outbound"))) TS_ChannelDetails_set_is_outbound(uint64_t this_ptr, jboolean val) {
28210 LDKChannelDetails this_ptr_conv;
28211 this_ptr_conv.inner = untag_ptr(this_ptr);
28212 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28214 this_ptr_conv.is_owned = false;
28215 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
28218 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_channel_ready"))) TS_ChannelDetails_get_is_channel_ready(uint64_t this_ptr) {
28219 LDKChannelDetails this_ptr_conv;
28220 this_ptr_conv.inner = untag_ptr(this_ptr);
28221 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28222 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28223 this_ptr_conv.is_owned = false;
28224 jboolean ret_conv = ChannelDetails_get_is_channel_ready(&this_ptr_conv);
28228 void __attribute__((export_name("TS_ChannelDetails_set_is_channel_ready"))) TS_ChannelDetails_set_is_channel_ready(uint64_t this_ptr, jboolean val) {
28229 LDKChannelDetails this_ptr_conv;
28230 this_ptr_conv.inner = untag_ptr(this_ptr);
28231 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28233 this_ptr_conv.is_owned = false;
28234 ChannelDetails_set_is_channel_ready(&this_ptr_conv, val);
28237 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_usable"))) TS_ChannelDetails_get_is_usable(uint64_t this_ptr) {
28238 LDKChannelDetails this_ptr_conv;
28239 this_ptr_conv.inner = untag_ptr(this_ptr);
28240 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28242 this_ptr_conv.is_owned = false;
28243 jboolean ret_conv = ChannelDetails_get_is_usable(&this_ptr_conv);
28247 void __attribute__((export_name("TS_ChannelDetails_set_is_usable"))) TS_ChannelDetails_set_is_usable(uint64_t this_ptr, jboolean val) {
28248 LDKChannelDetails this_ptr_conv;
28249 this_ptr_conv.inner = untag_ptr(this_ptr);
28250 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28252 this_ptr_conv.is_owned = false;
28253 ChannelDetails_set_is_usable(&this_ptr_conv, val);
28256 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_public"))) TS_ChannelDetails_get_is_public(uint64_t this_ptr) {
28257 LDKChannelDetails this_ptr_conv;
28258 this_ptr_conv.inner = untag_ptr(this_ptr);
28259 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28261 this_ptr_conv.is_owned = false;
28262 jboolean ret_conv = ChannelDetails_get_is_public(&this_ptr_conv);
28266 void __attribute__((export_name("TS_ChannelDetails_set_is_public"))) TS_ChannelDetails_set_is_public(uint64_t this_ptr, jboolean val) {
28267 LDKChannelDetails this_ptr_conv;
28268 this_ptr_conv.inner = untag_ptr(this_ptr);
28269 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28271 this_ptr_conv.is_owned = false;
28272 ChannelDetails_set_is_public(&this_ptr_conv, val);
28275 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_minimum_msat"))) TS_ChannelDetails_get_inbound_htlc_minimum_msat(uint64_t this_ptr) {
28276 LDKChannelDetails this_ptr_conv;
28277 this_ptr_conv.inner = untag_ptr(this_ptr);
28278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28280 this_ptr_conv.is_owned = false;
28281 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28282 *ret_copy = ChannelDetails_get_inbound_htlc_minimum_msat(&this_ptr_conv);
28283 uint64_t ret_ref = tag_ptr(ret_copy, true);
28287 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) {
28288 LDKChannelDetails this_ptr_conv;
28289 this_ptr_conv.inner = untag_ptr(this_ptr);
28290 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28292 this_ptr_conv.is_owned = false;
28293 void* val_ptr = untag_ptr(val);
28294 CHECK_ACCESS(val_ptr);
28295 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
28296 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
28297 ChannelDetails_set_inbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
28300 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_maximum_msat"))) TS_ChannelDetails_get_inbound_htlc_maximum_msat(uint64_t this_ptr) {
28301 LDKChannelDetails this_ptr_conv;
28302 this_ptr_conv.inner = untag_ptr(this_ptr);
28303 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28305 this_ptr_conv.is_owned = false;
28306 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28307 *ret_copy = ChannelDetails_get_inbound_htlc_maximum_msat(&this_ptr_conv);
28308 uint64_t ret_ref = tag_ptr(ret_copy, true);
28312 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) {
28313 LDKChannelDetails this_ptr_conv;
28314 this_ptr_conv.inner = untag_ptr(this_ptr);
28315 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28317 this_ptr_conv.is_owned = false;
28318 void* val_ptr = untag_ptr(val);
28319 CHECK_ACCESS(val_ptr);
28320 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
28321 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
28322 ChannelDetails_set_inbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
28325 uint64_t __attribute__((export_name("TS_ChannelDetails_get_config"))) TS_ChannelDetails_get_config(uint64_t this_ptr) {
28326 LDKChannelDetails this_ptr_conv;
28327 this_ptr_conv.inner = untag_ptr(this_ptr);
28328 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28329 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28330 this_ptr_conv.is_owned = false;
28331 LDKChannelConfig ret_var = ChannelDetails_get_config(&this_ptr_conv);
28332 uint64_t ret_ref = 0;
28333 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28334 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28338 void __attribute__((export_name("TS_ChannelDetails_set_config"))) TS_ChannelDetails_set_config(uint64_t this_ptr, uint64_t val) {
28339 LDKChannelDetails this_ptr_conv;
28340 this_ptr_conv.inner = untag_ptr(this_ptr);
28341 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28342 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28343 this_ptr_conv.is_owned = false;
28344 LDKChannelConfig val_conv;
28345 val_conv.inner = untag_ptr(val);
28346 val_conv.is_owned = ptr_is_owned(val);
28347 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
28348 val_conv = ChannelConfig_clone(&val_conv);
28349 ChannelDetails_set_config(&this_ptr_conv, val_conv);
28352 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, uint64_t feerate_sat_per_1000_weight_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) {
28353 LDKThirtyTwoBytes channel_id_arg_ref;
28354 CHECK(channel_id_arg->arr_len == 32);
28355 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
28356 LDKChannelCounterparty counterparty_arg_conv;
28357 counterparty_arg_conv.inner = untag_ptr(counterparty_arg);
28358 counterparty_arg_conv.is_owned = ptr_is_owned(counterparty_arg);
28359 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
28360 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
28361 LDKOutPoint funding_txo_arg_conv;
28362 funding_txo_arg_conv.inner = untag_ptr(funding_txo_arg);
28363 funding_txo_arg_conv.is_owned = ptr_is_owned(funding_txo_arg);
28364 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
28365 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
28366 LDKChannelTypeFeatures channel_type_arg_conv;
28367 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
28368 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
28369 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
28370 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
28371 void* short_channel_id_arg_ptr = untag_ptr(short_channel_id_arg);
28372 CHECK_ACCESS(short_channel_id_arg_ptr);
28373 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_arg_ptr);
28374 short_channel_id_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_arg));
28375 void* outbound_scid_alias_arg_ptr = untag_ptr(outbound_scid_alias_arg);
28376 CHECK_ACCESS(outbound_scid_alias_arg_ptr);
28377 LDKCOption_u64Z outbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(outbound_scid_alias_arg_ptr);
28378 outbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_scid_alias_arg));
28379 void* inbound_scid_alias_arg_ptr = untag_ptr(inbound_scid_alias_arg);
28380 CHECK_ACCESS(inbound_scid_alias_arg_ptr);
28381 LDKCOption_u64Z inbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(inbound_scid_alias_arg_ptr);
28382 inbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_scid_alias_arg));
28383 void* unspendable_punishment_reserve_arg_ptr = untag_ptr(unspendable_punishment_reserve_arg);
28384 CHECK_ACCESS(unspendable_punishment_reserve_arg_ptr);
28385 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(unspendable_punishment_reserve_arg_ptr);
28386 LDKU128 user_channel_id_arg_ref;
28387 CHECK(user_channel_id_arg->arr_len == 16);
28388 memcpy(user_channel_id_arg_ref.le_bytes, user_channel_id_arg->elems, 16); FREE(user_channel_id_arg);
28389 void* feerate_sat_per_1000_weight_arg_ptr = untag_ptr(feerate_sat_per_1000_weight_arg);
28390 CHECK_ACCESS(feerate_sat_per_1000_weight_arg_ptr);
28391 LDKCOption_u32Z feerate_sat_per_1000_weight_arg_conv = *(LDKCOption_u32Z*)(feerate_sat_per_1000_weight_arg_ptr);
28392 feerate_sat_per_1000_weight_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(feerate_sat_per_1000_weight_arg));
28393 void* confirmations_required_arg_ptr = untag_ptr(confirmations_required_arg);
28394 CHECK_ACCESS(confirmations_required_arg_ptr);
28395 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(confirmations_required_arg_ptr);
28396 confirmations_required_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_required_arg));
28397 void* confirmations_arg_ptr = untag_ptr(confirmations_arg);
28398 CHECK_ACCESS(confirmations_arg_ptr);
28399 LDKCOption_u32Z confirmations_arg_conv = *(LDKCOption_u32Z*)(confirmations_arg_ptr);
28400 confirmations_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_arg));
28401 void* force_close_spend_delay_arg_ptr = untag_ptr(force_close_spend_delay_arg);
28402 CHECK_ACCESS(force_close_spend_delay_arg_ptr);
28403 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(force_close_spend_delay_arg_ptr);
28404 force_close_spend_delay_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(force_close_spend_delay_arg));
28405 void* inbound_htlc_minimum_msat_arg_ptr = untag_ptr(inbound_htlc_minimum_msat_arg);
28406 CHECK_ACCESS(inbound_htlc_minimum_msat_arg_ptr);
28407 LDKCOption_u64Z inbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_minimum_msat_arg_ptr);
28408 inbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_minimum_msat_arg));
28409 void* inbound_htlc_maximum_msat_arg_ptr = untag_ptr(inbound_htlc_maximum_msat_arg);
28410 CHECK_ACCESS(inbound_htlc_maximum_msat_arg_ptr);
28411 LDKCOption_u64Z inbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_maximum_msat_arg_ptr);
28412 inbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_maximum_msat_arg));
28413 LDKChannelConfig config_arg_conv;
28414 config_arg_conv.inner = untag_ptr(config_arg);
28415 config_arg_conv.is_owned = ptr_is_owned(config_arg);
28416 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_arg_conv);
28417 config_arg_conv = ChannelConfig_clone(&config_arg_conv);
28418 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, feerate_sat_per_1000_weight_arg_conv, 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);
28419 uint64_t ret_ref = 0;
28420 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28421 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28425 static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
28426 LDKChannelDetails ret_var = ChannelDetails_clone(arg);
28427 uint64_t ret_ref = 0;
28428 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28429 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28432 int64_t __attribute__((export_name("TS_ChannelDetails_clone_ptr"))) TS_ChannelDetails_clone_ptr(uint64_t arg) {
28433 LDKChannelDetails arg_conv;
28434 arg_conv.inner = untag_ptr(arg);
28435 arg_conv.is_owned = ptr_is_owned(arg);
28436 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28437 arg_conv.is_owned = false;
28438 int64_t ret_conv = ChannelDetails_clone_ptr(&arg_conv);
28442 uint64_t __attribute__((export_name("TS_ChannelDetails_clone"))) TS_ChannelDetails_clone(uint64_t orig) {
28443 LDKChannelDetails orig_conv;
28444 orig_conv.inner = untag_ptr(orig);
28445 orig_conv.is_owned = ptr_is_owned(orig);
28446 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28447 orig_conv.is_owned = false;
28448 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
28449 uint64_t ret_ref = 0;
28450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28451 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28455 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_payment_scid"))) TS_ChannelDetails_get_inbound_payment_scid(uint64_t this_arg) {
28456 LDKChannelDetails this_arg_conv;
28457 this_arg_conv.inner = untag_ptr(this_arg);
28458 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28460 this_arg_conv.is_owned = false;
28461 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28462 *ret_copy = ChannelDetails_get_inbound_payment_scid(&this_arg_conv);
28463 uint64_t ret_ref = tag_ptr(ret_copy, true);
28467 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_payment_scid"))) TS_ChannelDetails_get_outbound_payment_scid(uint64_t this_arg) {
28468 LDKChannelDetails this_arg_conv;
28469 this_arg_conv.inner = untag_ptr(this_arg);
28470 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28472 this_arg_conv.is_owned = false;
28473 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28474 *ret_copy = ChannelDetails_get_outbound_payment_scid(&this_arg_conv);
28475 uint64_t ret_ref = tag_ptr(ret_copy, true);
28479 void __attribute__((export_name("TS_RecentPaymentDetails_free"))) TS_RecentPaymentDetails_free(uint64_t this_ptr) {
28480 if (!ptr_is_owned(this_ptr)) return;
28481 void* this_ptr_ptr = untag_ptr(this_ptr);
28482 CHECK_ACCESS(this_ptr_ptr);
28483 LDKRecentPaymentDetails this_ptr_conv = *(LDKRecentPaymentDetails*)(this_ptr_ptr);
28484 FREE(untag_ptr(this_ptr));
28485 RecentPaymentDetails_free(this_ptr_conv);
28488 static inline uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg) {
28489 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28490 *ret_copy = RecentPaymentDetails_clone(arg);
28491 uint64_t ret_ref = tag_ptr(ret_copy, true);
28494 int64_t __attribute__((export_name("TS_RecentPaymentDetails_clone_ptr"))) TS_RecentPaymentDetails_clone_ptr(uint64_t arg) {
28495 LDKRecentPaymentDetails* arg_conv = (LDKRecentPaymentDetails*)untag_ptr(arg);
28496 int64_t ret_conv = RecentPaymentDetails_clone_ptr(arg_conv);
28500 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_clone"))) TS_RecentPaymentDetails_clone(uint64_t orig) {
28501 LDKRecentPaymentDetails* orig_conv = (LDKRecentPaymentDetails*)untag_ptr(orig);
28502 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28503 *ret_copy = RecentPaymentDetails_clone(orig_conv);
28504 uint64_t ret_ref = tag_ptr(ret_copy, true);
28508 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_pending"))) TS_RecentPaymentDetails_pending(int8_tArray payment_hash, int64_t total_msat) {
28509 LDKThirtyTwoBytes payment_hash_ref;
28510 CHECK(payment_hash->arr_len == 32);
28511 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28512 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28513 *ret_copy = RecentPaymentDetails_pending(payment_hash_ref, total_msat);
28514 uint64_t ret_ref = tag_ptr(ret_copy, true);
28518 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_fulfilled"))) TS_RecentPaymentDetails_fulfilled(int8_tArray payment_hash) {
28519 LDKThirtyTwoBytes payment_hash_ref;
28520 CHECK(payment_hash->arr_len == 32);
28521 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28522 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28523 *ret_copy = RecentPaymentDetails_fulfilled(payment_hash_ref);
28524 uint64_t ret_ref = tag_ptr(ret_copy, true);
28528 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_abandoned"))) TS_RecentPaymentDetails_abandoned(int8_tArray payment_hash) {
28529 LDKThirtyTwoBytes payment_hash_ref;
28530 CHECK(payment_hash->arr_len == 32);
28531 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28532 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28533 *ret_copy = RecentPaymentDetails_abandoned(payment_hash_ref);
28534 uint64_t ret_ref = tag_ptr(ret_copy, true);
28538 void __attribute__((export_name("TS_PhantomRouteHints_free"))) TS_PhantomRouteHints_free(uint64_t this_obj) {
28539 LDKPhantomRouteHints this_obj_conv;
28540 this_obj_conv.inner = untag_ptr(this_obj);
28541 this_obj_conv.is_owned = ptr_is_owned(this_obj);
28542 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28543 PhantomRouteHints_free(this_obj_conv);
28546 uint64_tArray __attribute__((export_name("TS_PhantomRouteHints_get_channels"))) TS_PhantomRouteHints_get_channels(uint64_t this_ptr) {
28547 LDKPhantomRouteHints this_ptr_conv;
28548 this_ptr_conv.inner = untag_ptr(this_ptr);
28549 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28550 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28551 this_ptr_conv.is_owned = false;
28552 LDKCVec_ChannelDetailsZ ret_var = PhantomRouteHints_get_channels(&this_ptr_conv);
28553 uint64_tArray ret_arr = NULL;
28554 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28555 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28556 for (size_t q = 0; q < ret_var.datalen; q++) {
28557 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28558 uint64_t ret_conv_16_ref = 0;
28559 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28560 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28561 ret_arr_ptr[q] = ret_conv_16_ref;
28564 FREE(ret_var.data);
28568 void __attribute__((export_name("TS_PhantomRouteHints_set_channels"))) TS_PhantomRouteHints_set_channels(uint64_t this_ptr, uint64_tArray val) {
28569 LDKPhantomRouteHints this_ptr_conv;
28570 this_ptr_conv.inner = untag_ptr(this_ptr);
28571 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28573 this_ptr_conv.is_owned = false;
28574 LDKCVec_ChannelDetailsZ val_constr;
28575 val_constr.datalen = val->arr_len;
28576 if (val_constr.datalen > 0)
28577 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
28579 val_constr.data = NULL;
28580 uint64_t* val_vals = val->elems;
28581 for (size_t q = 0; q < val_constr.datalen; q++) {
28582 uint64_t val_conv_16 = val_vals[q];
28583 LDKChannelDetails val_conv_16_conv;
28584 val_conv_16_conv.inner = untag_ptr(val_conv_16);
28585 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
28586 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
28587 val_conv_16_conv = ChannelDetails_clone(&val_conv_16_conv);
28588 val_constr.data[q] = val_conv_16_conv;
28591 PhantomRouteHints_set_channels(&this_ptr_conv, val_constr);
28594 int64_t __attribute__((export_name("TS_PhantomRouteHints_get_phantom_scid"))) TS_PhantomRouteHints_get_phantom_scid(uint64_t this_ptr) {
28595 LDKPhantomRouteHints this_ptr_conv;
28596 this_ptr_conv.inner = untag_ptr(this_ptr);
28597 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28599 this_ptr_conv.is_owned = false;
28600 int64_t ret_conv = PhantomRouteHints_get_phantom_scid(&this_ptr_conv);
28604 void __attribute__((export_name("TS_PhantomRouteHints_set_phantom_scid"))) TS_PhantomRouteHints_set_phantom_scid(uint64_t this_ptr, int64_t val) {
28605 LDKPhantomRouteHints this_ptr_conv;
28606 this_ptr_conv.inner = untag_ptr(this_ptr);
28607 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28608 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28609 this_ptr_conv.is_owned = false;
28610 PhantomRouteHints_set_phantom_scid(&this_ptr_conv, val);
28613 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_get_real_node_pubkey"))) TS_PhantomRouteHints_get_real_node_pubkey(uint64_t this_ptr) {
28614 LDKPhantomRouteHints this_ptr_conv;
28615 this_ptr_conv.inner = untag_ptr(this_ptr);
28616 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28617 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28618 this_ptr_conv.is_owned = false;
28619 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28620 memcpy(ret_arr->elems, PhantomRouteHints_get_real_node_pubkey(&this_ptr_conv).compressed_form, 33);
28624 void __attribute__((export_name("TS_PhantomRouteHints_set_real_node_pubkey"))) TS_PhantomRouteHints_set_real_node_pubkey(uint64_t this_ptr, int8_tArray val) {
28625 LDKPhantomRouteHints this_ptr_conv;
28626 this_ptr_conv.inner = untag_ptr(this_ptr);
28627 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28629 this_ptr_conv.is_owned = false;
28630 LDKPublicKey val_ref;
28631 CHECK(val->arr_len == 33);
28632 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28633 PhantomRouteHints_set_real_node_pubkey(&this_ptr_conv, val_ref);
28636 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) {
28637 LDKCVec_ChannelDetailsZ channels_arg_constr;
28638 channels_arg_constr.datalen = channels_arg->arr_len;
28639 if (channels_arg_constr.datalen > 0)
28640 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
28642 channels_arg_constr.data = NULL;
28643 uint64_t* channels_arg_vals = channels_arg->elems;
28644 for (size_t q = 0; q < channels_arg_constr.datalen; q++) {
28645 uint64_t channels_arg_conv_16 = channels_arg_vals[q];
28646 LDKChannelDetails channels_arg_conv_16_conv;
28647 channels_arg_conv_16_conv.inner = untag_ptr(channels_arg_conv_16);
28648 channels_arg_conv_16_conv.is_owned = ptr_is_owned(channels_arg_conv_16);
28649 CHECK_INNER_FIELD_ACCESS_OR_NULL(channels_arg_conv_16_conv);
28650 channels_arg_conv_16_conv = ChannelDetails_clone(&channels_arg_conv_16_conv);
28651 channels_arg_constr.data[q] = channels_arg_conv_16_conv;
28653 FREE(channels_arg);
28654 LDKPublicKey real_node_pubkey_arg_ref;
28655 CHECK(real_node_pubkey_arg->arr_len == 33);
28656 memcpy(real_node_pubkey_arg_ref.compressed_form, real_node_pubkey_arg->elems, 33); FREE(real_node_pubkey_arg);
28657 LDKPhantomRouteHints ret_var = PhantomRouteHints_new(channels_arg_constr, phantom_scid_arg, real_node_pubkey_arg_ref);
28658 uint64_t ret_ref = 0;
28659 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28660 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28664 static inline uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg) {
28665 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(arg);
28666 uint64_t ret_ref = 0;
28667 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28668 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28671 int64_t __attribute__((export_name("TS_PhantomRouteHints_clone_ptr"))) TS_PhantomRouteHints_clone_ptr(uint64_t arg) {
28672 LDKPhantomRouteHints arg_conv;
28673 arg_conv.inner = untag_ptr(arg);
28674 arg_conv.is_owned = ptr_is_owned(arg);
28675 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28676 arg_conv.is_owned = false;
28677 int64_t ret_conv = PhantomRouteHints_clone_ptr(&arg_conv);
28681 uint64_t __attribute__((export_name("TS_PhantomRouteHints_clone"))) TS_PhantomRouteHints_clone(uint64_t orig) {
28682 LDKPhantomRouteHints orig_conv;
28683 orig_conv.inner = untag_ptr(orig);
28684 orig_conv.is_owned = ptr_is_owned(orig);
28685 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28686 orig_conv.is_owned = false;
28687 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(&orig_conv);
28688 uint64_t ret_ref = 0;
28689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28690 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28694 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 router, uint64_t logger, uint64_t entropy_source, uint64_t node_signer, uint64_t signer_provider, uint64_t config, uint64_t params) {
28695 void* fee_est_ptr = untag_ptr(fee_est);
28696 CHECK_ACCESS(fee_est_ptr);
28697 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(fee_est_ptr);
28698 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
28699 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28700 LDKFeeEstimator_JCalls_cloned(&fee_est_conv);
28702 void* chain_monitor_ptr = untag_ptr(chain_monitor);
28703 CHECK_ACCESS(chain_monitor_ptr);
28704 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
28705 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
28706 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28707 LDKWatch_JCalls_cloned(&chain_monitor_conv);
28709 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
28710 CHECK_ACCESS(tx_broadcaster_ptr);
28711 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
28712 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
28713 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28714 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
28716 void* router_ptr = untag_ptr(router);
28717 CHECK_ACCESS(router_ptr);
28718 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
28719 if (router_conv.free == LDKRouter_JCalls_free) {
28720 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28721 LDKRouter_JCalls_cloned(&router_conv);
28723 void* logger_ptr = untag_ptr(logger);
28724 CHECK_ACCESS(logger_ptr);
28725 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
28726 if (logger_conv.free == LDKLogger_JCalls_free) {
28727 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28728 LDKLogger_JCalls_cloned(&logger_conv);
28730 void* entropy_source_ptr = untag_ptr(entropy_source);
28731 CHECK_ACCESS(entropy_source_ptr);
28732 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
28733 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
28734 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28735 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
28737 void* node_signer_ptr = untag_ptr(node_signer);
28738 CHECK_ACCESS(node_signer_ptr);
28739 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
28740 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
28741 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28742 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
28744 void* signer_provider_ptr = untag_ptr(signer_provider);
28745 CHECK_ACCESS(signer_provider_ptr);
28746 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
28747 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
28748 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28749 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
28751 LDKUserConfig config_conv;
28752 config_conv.inner = untag_ptr(config);
28753 config_conv.is_owned = ptr_is_owned(config);
28754 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
28755 config_conv = UserConfig_clone(&config_conv);
28756 LDKChainParameters params_conv;
28757 params_conv.inner = untag_ptr(params);
28758 params_conv.is_owned = ptr_is_owned(params);
28759 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
28760 params_conv = ChainParameters_clone(¶ms_conv);
28761 LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, router_conv, logger_conv, entropy_source_conv, node_signer_conv, signer_provider_conv, config_conv, params_conv);
28762 uint64_t ret_ref = 0;
28763 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28764 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28768 uint64_t __attribute__((export_name("TS_ChannelManager_get_current_default_configuration"))) TS_ChannelManager_get_current_default_configuration(uint64_t this_arg) {
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 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
28775 uint64_t ret_ref = 0;
28776 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28777 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28781 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) {
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 LDKPublicKey their_network_key_ref;
28788 CHECK(their_network_key->arr_len == 33);
28789 memcpy(their_network_key_ref.compressed_form, their_network_key->elems, 33); FREE(their_network_key);
28790 LDKU128 user_channel_id_ref;
28791 CHECK(user_channel_id->arr_len == 16);
28792 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
28793 LDKUserConfig override_config_conv;
28794 override_config_conv.inner = untag_ptr(override_config);
28795 override_config_conv.is_owned = ptr_is_owned(override_config);
28796 CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
28797 override_config_conv = UserConfig_clone(&override_config_conv);
28798 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
28799 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id_ref, override_config_conv);
28800 return tag_ptr(ret_conv, true);
28803 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_channels"))) TS_ChannelManager_list_channels(uint64_t this_arg) {
28804 LDKChannelManager this_arg_conv;
28805 this_arg_conv.inner = untag_ptr(this_arg);
28806 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28808 this_arg_conv.is_owned = false;
28809 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
28810 uint64_tArray ret_arr = NULL;
28811 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28812 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28813 for (size_t q = 0; q < ret_var.datalen; q++) {
28814 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28815 uint64_t ret_conv_16_ref = 0;
28816 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28817 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28818 ret_arr_ptr[q] = ret_conv_16_ref;
28821 FREE(ret_var.data);
28825 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_usable_channels"))) TS_ChannelManager_list_usable_channels(uint64_t this_arg) {
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 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
28832 uint64_tArray ret_arr = NULL;
28833 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28834 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28835 for (size_t q = 0; q < ret_var.datalen; q++) {
28836 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28837 uint64_t ret_conv_16_ref = 0;
28838 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28839 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28840 ret_arr_ptr[q] = ret_conv_16_ref;
28843 FREE(ret_var.data);
28847 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_channels_with_counterparty"))) TS_ChannelManager_list_channels_with_counterparty(uint64_t this_arg, int8_tArray counterparty_node_id) {
28848 LDKChannelManager this_arg_conv;
28849 this_arg_conv.inner = untag_ptr(this_arg);
28850 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28852 this_arg_conv.is_owned = false;
28853 LDKPublicKey counterparty_node_id_ref;
28854 CHECK(counterparty_node_id->arr_len == 33);
28855 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28856 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels_with_counterparty(&this_arg_conv, counterparty_node_id_ref);
28857 uint64_tArray ret_arr = NULL;
28858 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28859 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28860 for (size_t q = 0; q < ret_var.datalen; q++) {
28861 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28862 uint64_t ret_conv_16_ref = 0;
28863 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28864 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28865 ret_arr_ptr[q] = ret_conv_16_ref;
28868 FREE(ret_var.data);
28872 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_recent_payments"))) TS_ChannelManager_list_recent_payments(uint64_t this_arg) {
28873 LDKChannelManager this_arg_conv;
28874 this_arg_conv.inner = untag_ptr(this_arg);
28875 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28877 this_arg_conv.is_owned = false;
28878 LDKCVec_RecentPaymentDetailsZ ret_var = ChannelManager_list_recent_payments(&this_arg_conv);
28879 uint64_tArray ret_arr = NULL;
28880 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28881 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28882 for (size_t w = 0; w < ret_var.datalen; w++) {
28883 LDKRecentPaymentDetails *ret_conv_22_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28884 *ret_conv_22_copy = ret_var.data[w];
28885 uint64_t ret_conv_22_ref = tag_ptr(ret_conv_22_copy, true);
28886 ret_arr_ptr[w] = ret_conv_22_ref;
28889 FREE(ret_var.data);
28893 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) {
28894 LDKChannelManager this_arg_conv;
28895 this_arg_conv.inner = untag_ptr(this_arg);
28896 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28898 this_arg_conv.is_owned = false;
28899 uint8_t channel_id_arr[32];
28900 CHECK(channel_id->arr_len == 32);
28901 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28902 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28903 LDKPublicKey counterparty_node_id_ref;
28904 CHECK(counterparty_node_id->arr_len == 33);
28905 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28906 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28907 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28908 return tag_ptr(ret_conv, true);
28911 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) {
28912 LDKChannelManager this_arg_conv;
28913 this_arg_conv.inner = untag_ptr(this_arg);
28914 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28916 this_arg_conv.is_owned = false;
28917 uint8_t channel_id_arr[32];
28918 CHECK(channel_id->arr_len == 32);
28919 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28920 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28921 LDKPublicKey counterparty_node_id_ref;
28922 CHECK(counterparty_node_id->arr_len == 33);
28923 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28924 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28925 *ret_conv = ChannelManager_close_channel_with_target_feerate(&this_arg_conv, channel_id_ref, counterparty_node_id_ref, target_feerate_sats_per_1000_weight);
28926 return tag_ptr(ret_conv, true);
28929 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) {
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 uint8_t channel_id_arr[32];
28936 CHECK(channel_id->arr_len == 32);
28937 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28938 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28939 LDKPublicKey counterparty_node_id_ref;
28940 CHECK(counterparty_node_id->arr_len == 33);
28941 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28942 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28943 *ret_conv = ChannelManager_force_close_broadcasting_latest_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28944 return tag_ptr(ret_conv, true);
28947 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) {
28948 LDKChannelManager this_arg_conv;
28949 this_arg_conv.inner = untag_ptr(this_arg);
28950 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28952 this_arg_conv.is_owned = false;
28953 uint8_t channel_id_arr[32];
28954 CHECK(channel_id->arr_len == 32);
28955 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28956 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28957 LDKPublicKey counterparty_node_id_ref;
28958 CHECK(counterparty_node_id->arr_len == 33);
28959 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28960 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28961 *ret_conv = ChannelManager_force_close_without_broadcasting_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28962 return tag_ptr(ret_conv, true);
28965 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) {
28966 LDKChannelManager this_arg_conv;
28967 this_arg_conv.inner = untag_ptr(this_arg);
28968 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28970 this_arg_conv.is_owned = false;
28971 ChannelManager_force_close_all_channels_broadcasting_latest_txn(&this_arg_conv);
28974 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) {
28975 LDKChannelManager this_arg_conv;
28976 this_arg_conv.inner = untag_ptr(this_arg);
28977 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28979 this_arg_conv.is_owned = false;
28980 ChannelManager_force_close_all_channels_without_broadcasting_txn(&this_arg_conv);
28983 uint64_t __attribute__((export_name("TS_ChannelManager_send_payment_with_route"))) TS_ChannelManager_send_payment_with_route(uint64_t this_arg, uint64_t route, int8_tArray payment_hash, uint64_t recipient_onion, int8_tArray payment_id) {
28984 LDKChannelManager this_arg_conv;
28985 this_arg_conv.inner = untag_ptr(this_arg);
28986 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28988 this_arg_conv.is_owned = false;
28989 LDKRoute route_conv;
28990 route_conv.inner = untag_ptr(route);
28991 route_conv.is_owned = ptr_is_owned(route);
28992 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
28993 route_conv.is_owned = false;
28994 LDKThirtyTwoBytes payment_hash_ref;
28995 CHECK(payment_hash->arr_len == 32);
28996 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28997 LDKRecipientOnionFields recipient_onion_conv;
28998 recipient_onion_conv.inner = untag_ptr(recipient_onion);
28999 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29000 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29001 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29002 LDKThirtyTwoBytes payment_id_ref;
29003 CHECK(payment_id->arr_len == 32);
29004 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29005 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
29006 *ret_conv = ChannelManager_send_payment_with_route(&this_arg_conv, &route_conv, payment_hash_ref, recipient_onion_conv, payment_id_ref);
29007 return tag_ptr(ret_conv, true);
29010 uint64_t __attribute__((export_name("TS_ChannelManager_send_payment"))) TS_ChannelManager_send_payment(uint64_t this_arg, int8_tArray payment_hash, uint64_t recipient_onion, int8_tArray payment_id, uint64_t route_params, uint64_t retry_strategy) {
29011 LDKChannelManager this_arg_conv;
29012 this_arg_conv.inner = untag_ptr(this_arg);
29013 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29014 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29015 this_arg_conv.is_owned = false;
29016 LDKThirtyTwoBytes payment_hash_ref;
29017 CHECK(payment_hash->arr_len == 32);
29018 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29019 LDKRecipientOnionFields recipient_onion_conv;
29020 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29021 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29022 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29023 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29024 LDKThirtyTwoBytes payment_id_ref;
29025 CHECK(payment_id->arr_len == 32);
29026 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29027 LDKRouteParameters route_params_conv;
29028 route_params_conv.inner = untag_ptr(route_params);
29029 route_params_conv.is_owned = ptr_is_owned(route_params);
29030 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
29031 route_params_conv = RouteParameters_clone(&route_params_conv);
29032 void* retry_strategy_ptr = untag_ptr(retry_strategy);
29033 CHECK_ACCESS(retry_strategy_ptr);
29034 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
29035 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
29036 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
29037 *ret_conv = ChannelManager_send_payment(&this_arg_conv, payment_hash_ref, recipient_onion_conv, payment_id_ref, route_params_conv, retry_strategy_conv);
29038 return tag_ptr(ret_conv, true);
29041 void __attribute__((export_name("TS_ChannelManager_abandon_payment"))) TS_ChannelManager_abandon_payment(uint64_t this_arg, int8_tArray payment_id) {
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 LDKThirtyTwoBytes payment_id_ref;
29048 CHECK(payment_id->arr_len == 32);
29049 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29050 ChannelManager_abandon_payment(&this_arg_conv, payment_id_ref);
29053 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, uint64_t recipient_onion, int8_tArray payment_id) {
29054 LDKChannelManager this_arg_conv;
29055 this_arg_conv.inner = untag_ptr(this_arg);
29056 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29058 this_arg_conv.is_owned = false;
29059 LDKRoute route_conv;
29060 route_conv.inner = untag_ptr(route);
29061 route_conv.is_owned = ptr_is_owned(route);
29062 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
29063 route_conv.is_owned = false;
29064 LDKThirtyTwoBytes payment_preimage_ref;
29065 CHECK(payment_preimage->arr_len == 32);
29066 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
29067 LDKRecipientOnionFields recipient_onion_conv;
29068 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29069 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29070 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29071 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29072 LDKThirtyTwoBytes payment_id_ref;
29073 CHECK(payment_id->arr_len == 32);
29074 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29075 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
29076 *ret_conv = ChannelManager_send_spontaneous_payment(&this_arg_conv, &route_conv, payment_preimage_ref, recipient_onion_conv, payment_id_ref);
29077 return tag_ptr(ret_conv, true);
29080 uint64_t __attribute__((export_name("TS_ChannelManager_send_spontaneous_payment_with_retry"))) TS_ChannelManager_send_spontaneous_payment_with_retry(uint64_t this_arg, int8_tArray payment_preimage, uint64_t recipient_onion, int8_tArray payment_id, uint64_t route_params, uint64_t retry_strategy) {
29081 LDKChannelManager this_arg_conv;
29082 this_arg_conv.inner = untag_ptr(this_arg);
29083 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29085 this_arg_conv.is_owned = false;
29086 LDKThirtyTwoBytes payment_preimage_ref;
29087 CHECK(payment_preimage->arr_len == 32);
29088 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
29089 LDKRecipientOnionFields recipient_onion_conv;
29090 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29091 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29092 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29093 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29094 LDKThirtyTwoBytes payment_id_ref;
29095 CHECK(payment_id->arr_len == 32);
29096 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29097 LDKRouteParameters route_params_conv;
29098 route_params_conv.inner = untag_ptr(route_params);
29099 route_params_conv.is_owned = ptr_is_owned(route_params);
29100 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
29101 route_params_conv = RouteParameters_clone(&route_params_conv);
29102 void* retry_strategy_ptr = untag_ptr(retry_strategy);
29103 CHECK_ACCESS(retry_strategy_ptr);
29104 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
29105 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
29106 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
29107 *ret_conv = ChannelManager_send_spontaneous_payment_with_retry(&this_arg_conv, payment_preimage_ref, recipient_onion_conv, payment_id_ref, route_params_conv, retry_strategy_conv);
29108 return tag_ptr(ret_conv, true);
29111 uint64_t __attribute__((export_name("TS_ChannelManager_send_probe"))) TS_ChannelManager_send_probe(uint64_t this_arg, uint64_t path) {
29112 LDKChannelManager this_arg_conv;
29113 this_arg_conv.inner = untag_ptr(this_arg);
29114 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29116 this_arg_conv.is_owned = false;
29118 path_conv.inner = untag_ptr(path);
29119 path_conv.is_owned = ptr_is_owned(path);
29120 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
29121 path_conv = Path_clone(&path_conv);
29122 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
29123 *ret_conv = ChannelManager_send_probe(&this_arg_conv, path_conv);
29124 return tag_ptr(ret_conv, true);
29127 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) {
29128 LDKChannelManager this_arg_conv;
29129 this_arg_conv.inner = untag_ptr(this_arg);
29130 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29132 this_arg_conv.is_owned = false;
29133 uint8_t temporary_channel_id_arr[32];
29134 CHECK(temporary_channel_id->arr_len == 32);
29135 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
29136 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
29137 LDKPublicKey counterparty_node_id_ref;
29138 CHECK(counterparty_node_id->arr_len == 33);
29139 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29140 LDKTransaction funding_transaction_ref;
29141 funding_transaction_ref.datalen = funding_transaction->arr_len;
29142 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
29143 memcpy(funding_transaction_ref.data, funding_transaction->elems, funding_transaction_ref.datalen); FREE(funding_transaction);
29144 funding_transaction_ref.data_is_owned = true;
29145 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29146 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, funding_transaction_ref);
29147 return tag_ptr(ret_conv, true);
29150 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) {
29151 LDKChannelManager this_arg_conv;
29152 this_arg_conv.inner = untag_ptr(this_arg);
29153 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29155 this_arg_conv.is_owned = false;
29156 LDKPublicKey counterparty_node_id_ref;
29157 CHECK(counterparty_node_id->arr_len == 33);
29158 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29159 LDKCVec_ThirtyTwoBytesZ channel_ids_constr;
29160 channel_ids_constr.datalen = channel_ids->arr_len;
29161 if (channel_ids_constr.datalen > 0)
29162 channel_ids_constr.data = MALLOC(channel_ids_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
29164 channel_ids_constr.data = NULL;
29165 int8_tArray* channel_ids_vals = (void*) channel_ids->elems;
29166 for (size_t m = 0; m < channel_ids_constr.datalen; m++) {
29167 int8_tArray channel_ids_conv_12 = channel_ids_vals[m];
29168 LDKThirtyTwoBytes channel_ids_conv_12_ref;
29169 CHECK(channel_ids_conv_12->arr_len == 32);
29170 memcpy(channel_ids_conv_12_ref.data, channel_ids_conv_12->elems, 32); FREE(channel_ids_conv_12);
29171 channel_ids_constr.data[m] = channel_ids_conv_12_ref;
29174 LDKChannelConfig config_conv;
29175 config_conv.inner = untag_ptr(config);
29176 config_conv.is_owned = ptr_is_owned(config);
29177 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
29178 config_conv.is_owned = false;
29179 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29180 *ret_conv = ChannelManager_update_channel_config(&this_arg_conv, counterparty_node_id_ref, channel_ids_constr, &config_conv);
29181 return tag_ptr(ret_conv, true);
29184 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) {
29185 LDKChannelManager this_arg_conv;
29186 this_arg_conv.inner = untag_ptr(this_arg);
29187 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29189 this_arg_conv.is_owned = false;
29190 LDKThirtyTwoBytes intercept_id_ref;
29191 CHECK(intercept_id->arr_len == 32);
29192 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
29193 uint8_t next_hop_channel_id_arr[32];
29194 CHECK(next_hop_channel_id->arr_len == 32);
29195 memcpy(next_hop_channel_id_arr, next_hop_channel_id->elems, 32); FREE(next_hop_channel_id);
29196 uint8_t (*next_hop_channel_id_ref)[32] = &next_hop_channel_id_arr;
29197 LDKPublicKey next_node_id_ref;
29198 CHECK(next_node_id->arr_len == 33);
29199 memcpy(next_node_id_ref.compressed_form, next_node_id->elems, 33); FREE(next_node_id);
29200 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29201 *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);
29202 return tag_ptr(ret_conv, true);
29205 uint64_t __attribute__((export_name("TS_ChannelManager_fail_intercepted_htlc"))) TS_ChannelManager_fail_intercepted_htlc(uint64_t this_arg, int8_tArray intercept_id) {
29206 LDKChannelManager this_arg_conv;
29207 this_arg_conv.inner = untag_ptr(this_arg);
29208 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29210 this_arg_conv.is_owned = false;
29211 LDKThirtyTwoBytes intercept_id_ref;
29212 CHECK(intercept_id->arr_len == 32);
29213 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
29214 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29215 *ret_conv = ChannelManager_fail_intercepted_htlc(&this_arg_conv, intercept_id_ref);
29216 return tag_ptr(ret_conv, true);
29219 void __attribute__((export_name("TS_ChannelManager_process_pending_htlc_forwards"))) TS_ChannelManager_process_pending_htlc_forwards(uint64_t this_arg) {
29220 LDKChannelManager this_arg_conv;
29221 this_arg_conv.inner = untag_ptr(this_arg);
29222 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29223 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29224 this_arg_conv.is_owned = false;
29225 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
29228 void __attribute__((export_name("TS_ChannelManager_timer_tick_occurred"))) TS_ChannelManager_timer_tick_occurred(uint64_t this_arg) {
29229 LDKChannelManager this_arg_conv;
29230 this_arg_conv.inner = untag_ptr(this_arg);
29231 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29233 this_arg_conv.is_owned = false;
29234 ChannelManager_timer_tick_occurred(&this_arg_conv);
29237 void __attribute__((export_name("TS_ChannelManager_fail_htlc_backwards"))) TS_ChannelManager_fail_htlc_backwards(uint64_t this_arg, int8_tArray payment_hash) {
29238 LDKChannelManager this_arg_conv;
29239 this_arg_conv.inner = untag_ptr(this_arg);
29240 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29242 this_arg_conv.is_owned = false;
29243 uint8_t payment_hash_arr[32];
29244 CHECK(payment_hash->arr_len == 32);
29245 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
29246 uint8_t (*payment_hash_ref)[32] = &payment_hash_arr;
29247 ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
29250 void __attribute__((export_name("TS_ChannelManager_fail_htlc_backwards_with_reason"))) TS_ChannelManager_fail_htlc_backwards_with_reason(uint64_t this_arg, int8_tArray payment_hash, uint32_t failure_code) {
29251 LDKChannelManager this_arg_conv;
29252 this_arg_conv.inner = untag_ptr(this_arg);
29253 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29254 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29255 this_arg_conv.is_owned = false;
29256 uint8_t payment_hash_arr[32];
29257 CHECK(payment_hash->arr_len == 32);
29258 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
29259 uint8_t (*payment_hash_ref)[32] = &payment_hash_arr;
29260 LDKFailureCode failure_code_conv = LDKFailureCode_from_js(failure_code);
29261 ChannelManager_fail_htlc_backwards_with_reason(&this_arg_conv, payment_hash_ref, failure_code_conv);
29264 void __attribute__((export_name("TS_ChannelManager_claim_funds"))) TS_ChannelManager_claim_funds(uint64_t this_arg, int8_tArray payment_preimage) {
29265 LDKChannelManager this_arg_conv;
29266 this_arg_conv.inner = untag_ptr(this_arg);
29267 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29269 this_arg_conv.is_owned = false;
29270 LDKThirtyTwoBytes payment_preimage_ref;
29271 CHECK(payment_preimage->arr_len == 32);
29272 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
29273 ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
29276 int8_tArray __attribute__((export_name("TS_ChannelManager_get_our_node_id"))) TS_ChannelManager_get_our_node_id(uint64_t this_arg) {
29277 LDKChannelManager this_arg_conv;
29278 this_arg_conv.inner = untag_ptr(this_arg);
29279 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29280 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29281 this_arg_conv.is_owned = false;
29282 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29283 memcpy(ret_arr->elems, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
29287 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) {
29288 LDKChannelManager this_arg_conv;
29289 this_arg_conv.inner = untag_ptr(this_arg);
29290 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29292 this_arg_conv.is_owned = false;
29293 uint8_t temporary_channel_id_arr[32];
29294 CHECK(temporary_channel_id->arr_len == 32);
29295 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
29296 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
29297 LDKPublicKey counterparty_node_id_ref;
29298 CHECK(counterparty_node_id->arr_len == 33);
29299 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29300 LDKU128 user_channel_id_ref;
29301 CHECK(user_channel_id->arr_len == 16);
29302 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
29303 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29304 *ret_conv = ChannelManager_accept_inbound_channel(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id_ref);
29305 return tag_ptr(ret_conv, true);
29308 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) {
29309 LDKChannelManager this_arg_conv;
29310 this_arg_conv.inner = untag_ptr(this_arg);
29311 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29312 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29313 this_arg_conv.is_owned = false;
29314 uint8_t temporary_channel_id_arr[32];
29315 CHECK(temporary_channel_id->arr_len == 32);
29316 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
29317 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
29318 LDKPublicKey counterparty_node_id_ref;
29319 CHECK(counterparty_node_id->arr_len == 33);
29320 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29321 LDKU128 user_channel_id_ref;
29322 CHECK(user_channel_id->arr_len == 16);
29323 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
29324 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29325 *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);
29326 return tag_ptr(ret_conv, true);
29329 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, uint64_t min_final_cltv_expiry_delta) {
29330 LDKChannelManager this_arg_conv;
29331 this_arg_conv.inner = untag_ptr(this_arg);
29332 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29333 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29334 this_arg_conv.is_owned = false;
29335 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29336 CHECK_ACCESS(min_value_msat_ptr);
29337 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29338 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29339 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
29340 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
29341 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
29342 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
29343 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
29344 *ret_conv = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, min_final_cltv_expiry_delta_conv);
29345 return tag_ptr(ret_conv, true);
29348 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) {
29349 LDKChannelManager this_arg_conv;
29350 this_arg_conv.inner = untag_ptr(this_arg);
29351 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29353 this_arg_conv.is_owned = false;
29354 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29355 CHECK_ACCESS(min_value_msat_ptr);
29356 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29357 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29358 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
29359 *ret_conv = ChannelManager_create_inbound_payment_legacy(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs);
29360 return tag_ptr(ret_conv, true);
29363 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, uint64_t min_final_cltv_expiry) {
29364 LDKChannelManager this_arg_conv;
29365 this_arg_conv.inner = untag_ptr(this_arg);
29366 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29367 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29368 this_arg_conv.is_owned = false;
29369 LDKThirtyTwoBytes payment_hash_ref;
29370 CHECK(payment_hash->arr_len == 32);
29371 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29372 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29373 CHECK_ACCESS(min_value_msat_ptr);
29374 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29375 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29376 void* min_final_cltv_expiry_ptr = untag_ptr(min_final_cltv_expiry);
29377 CHECK_ACCESS(min_final_cltv_expiry_ptr);
29378 LDKCOption_u16Z min_final_cltv_expiry_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_ptr);
29379 min_final_cltv_expiry_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry));
29380 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
29381 *ret_conv = ChannelManager_create_inbound_payment_for_hash(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs, min_final_cltv_expiry_conv);
29382 return tag_ptr(ret_conv, true);
29385 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) {
29386 LDKChannelManager this_arg_conv;
29387 this_arg_conv.inner = untag_ptr(this_arg);
29388 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29390 this_arg_conv.is_owned = false;
29391 LDKThirtyTwoBytes payment_hash_ref;
29392 CHECK(payment_hash->arr_len == 32);
29393 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29394 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29395 CHECK_ACCESS(min_value_msat_ptr);
29396 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29397 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29398 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
29399 *ret_conv = ChannelManager_create_inbound_payment_for_hash_legacy(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs);
29400 return tag_ptr(ret_conv, true);
29403 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) {
29404 LDKChannelManager this_arg_conv;
29405 this_arg_conv.inner = untag_ptr(this_arg);
29406 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29408 this_arg_conv.is_owned = false;
29409 LDKThirtyTwoBytes payment_hash_ref;
29410 CHECK(payment_hash->arr_len == 32);
29411 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29412 LDKThirtyTwoBytes payment_secret_ref;
29413 CHECK(payment_secret->arr_len == 32);
29414 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
29415 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
29416 *ret_conv = ChannelManager_get_payment_preimage(&this_arg_conv, payment_hash_ref, payment_secret_ref);
29417 return tag_ptr(ret_conv, true);
29420 int64_t __attribute__((export_name("TS_ChannelManager_get_phantom_scid"))) TS_ChannelManager_get_phantom_scid(uint64_t this_arg) {
29421 LDKChannelManager this_arg_conv;
29422 this_arg_conv.inner = untag_ptr(this_arg);
29423 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29424 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29425 this_arg_conv.is_owned = false;
29426 int64_t ret_conv = ChannelManager_get_phantom_scid(&this_arg_conv);
29430 uint64_t __attribute__((export_name("TS_ChannelManager_get_phantom_route_hints"))) TS_ChannelManager_get_phantom_route_hints(uint64_t this_arg) {
29431 LDKChannelManager this_arg_conv;
29432 this_arg_conv.inner = untag_ptr(this_arg);
29433 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29435 this_arg_conv.is_owned = false;
29436 LDKPhantomRouteHints ret_var = ChannelManager_get_phantom_route_hints(&this_arg_conv);
29437 uint64_t ret_ref = 0;
29438 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29439 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29443 int64_t __attribute__((export_name("TS_ChannelManager_get_intercept_scid"))) TS_ChannelManager_get_intercept_scid(uint64_t this_arg) {
29444 LDKChannelManager this_arg_conv;
29445 this_arg_conv.inner = untag_ptr(this_arg);
29446 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29447 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29448 this_arg_conv.is_owned = false;
29449 int64_t ret_conv = ChannelManager_get_intercept_scid(&this_arg_conv);
29453 uint64_t __attribute__((export_name("TS_ChannelManager_compute_inflight_htlcs"))) TS_ChannelManager_compute_inflight_htlcs(uint64_t this_arg) {
29454 LDKChannelManager this_arg_conv;
29455 this_arg_conv.inner = untag_ptr(this_arg);
29456 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29458 this_arg_conv.is_owned = false;
29459 LDKInFlightHtlcs ret_var = ChannelManager_compute_inflight_htlcs(&this_arg_conv);
29460 uint64_t ret_ref = 0;
29461 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29462 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29466 uint64_t __attribute__((export_name("TS_ChannelManager_as_MessageSendEventsProvider"))) TS_ChannelManager_as_MessageSendEventsProvider(uint64_t this_arg) {
29467 LDKChannelManager this_arg_conv;
29468 this_arg_conv.inner = untag_ptr(this_arg);
29469 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29471 this_arg_conv.is_owned = false;
29472 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
29473 *ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
29474 return tag_ptr(ret_ret, true);
29477 uint64_t __attribute__((export_name("TS_ChannelManager_as_EventsProvider"))) TS_ChannelManager_as_EventsProvider(uint64_t this_arg) {
29478 LDKChannelManager this_arg_conv;
29479 this_arg_conv.inner = untag_ptr(this_arg);
29480 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29482 this_arg_conv.is_owned = false;
29483 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
29484 *ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
29485 return tag_ptr(ret_ret, true);
29488 uint64_t __attribute__((export_name("TS_ChannelManager_as_Listen"))) TS_ChannelManager_as_Listen(uint64_t this_arg) {
29489 LDKChannelManager this_arg_conv;
29490 this_arg_conv.inner = untag_ptr(this_arg);
29491 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29493 this_arg_conv.is_owned = false;
29494 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
29495 *ret_ret = ChannelManager_as_Listen(&this_arg_conv);
29496 return tag_ptr(ret_ret, true);
29499 uint64_t __attribute__((export_name("TS_ChannelManager_as_Confirm"))) TS_ChannelManager_as_Confirm(uint64_t this_arg) {
29500 LDKChannelManager this_arg_conv;
29501 this_arg_conv.inner = untag_ptr(this_arg);
29502 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29504 this_arg_conv.is_owned = false;
29505 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
29506 *ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
29507 return tag_ptr(ret_ret, true);
29510 uint64_t __attribute__((export_name("TS_ChannelManager_get_persistable_update_future"))) TS_ChannelManager_get_persistable_update_future(uint64_t this_arg) {
29511 LDKChannelManager this_arg_conv;
29512 this_arg_conv.inner = untag_ptr(this_arg);
29513 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29515 this_arg_conv.is_owned = false;
29516 LDKFuture ret_var = ChannelManager_get_persistable_update_future(&this_arg_conv);
29517 uint64_t ret_ref = 0;
29518 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29519 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29523 uint64_t __attribute__((export_name("TS_ChannelManager_current_best_block"))) TS_ChannelManager_current_best_block(uint64_t this_arg) {
29524 LDKChannelManager this_arg_conv;
29525 this_arg_conv.inner = untag_ptr(this_arg);
29526 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29528 this_arg_conv.is_owned = false;
29529 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
29530 uint64_t ret_ref = 0;
29531 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29532 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29536 uint64_t __attribute__((export_name("TS_ChannelManager_node_features"))) TS_ChannelManager_node_features(uint64_t this_arg) {
29537 LDKChannelManager this_arg_conv;
29538 this_arg_conv.inner = untag_ptr(this_arg);
29539 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29541 this_arg_conv.is_owned = false;
29542 LDKNodeFeatures ret_var = ChannelManager_node_features(&this_arg_conv);
29543 uint64_t ret_ref = 0;
29544 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29545 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29549 uint64_t __attribute__((export_name("TS_ChannelManager_channel_features"))) TS_ChannelManager_channel_features(uint64_t this_arg) {
29550 LDKChannelManager this_arg_conv;
29551 this_arg_conv.inner = untag_ptr(this_arg);
29552 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29554 this_arg_conv.is_owned = false;
29555 LDKChannelFeatures ret_var = ChannelManager_channel_features(&this_arg_conv);
29556 uint64_t ret_ref = 0;
29557 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29558 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29562 uint64_t __attribute__((export_name("TS_ChannelManager_channel_type_features"))) TS_ChannelManager_channel_type_features(uint64_t this_arg) {
29563 LDKChannelManager this_arg_conv;
29564 this_arg_conv.inner = untag_ptr(this_arg);
29565 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29567 this_arg_conv.is_owned = false;
29568 LDKChannelTypeFeatures ret_var = ChannelManager_channel_type_features(&this_arg_conv);
29569 uint64_t ret_ref = 0;
29570 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29571 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29575 uint64_t __attribute__((export_name("TS_ChannelManager_init_features"))) TS_ChannelManager_init_features(uint64_t this_arg) {
29576 LDKChannelManager this_arg_conv;
29577 this_arg_conv.inner = untag_ptr(this_arg);
29578 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29580 this_arg_conv.is_owned = false;
29581 LDKInitFeatures ret_var = ChannelManager_init_features(&this_arg_conv);
29582 uint64_t ret_ref = 0;
29583 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29584 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29588 uint64_t __attribute__((export_name("TS_ChannelManager_as_ChannelMessageHandler"))) TS_ChannelManager_as_ChannelMessageHandler(uint64_t this_arg) {
29589 LDKChannelManager this_arg_conv;
29590 this_arg_conv.inner = untag_ptr(this_arg);
29591 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29593 this_arg_conv.is_owned = false;
29594 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
29595 *ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
29596 return tag_ptr(ret_ret, true);
29599 uint64_t __attribute__((export_name("TS_provided_init_features"))) TS_provided_init_features(uint64_t _config) {
29600 LDKUserConfig _config_conv;
29601 _config_conv.inner = untag_ptr(_config);
29602 _config_conv.is_owned = ptr_is_owned(_config);
29603 CHECK_INNER_FIELD_ACCESS_OR_NULL(_config_conv);
29604 _config_conv.is_owned = false;
29605 LDKInitFeatures ret_var = provided_init_features(&_config_conv);
29606 uint64_t ret_ref = 0;
29607 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29608 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29612 int8_tArray __attribute__((export_name("TS_CounterpartyForwardingInfo_write"))) TS_CounterpartyForwardingInfo_write(uint64_t obj) {
29613 LDKCounterpartyForwardingInfo obj_conv;
29614 obj_conv.inner = untag_ptr(obj);
29615 obj_conv.is_owned = ptr_is_owned(obj);
29616 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29617 obj_conv.is_owned = false;
29618 LDKCVec_u8Z ret_var = CounterpartyForwardingInfo_write(&obj_conv);
29619 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29620 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29621 CVec_u8Z_free(ret_var);
29625 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_read"))) TS_CounterpartyForwardingInfo_read(int8_tArray ser) {
29626 LDKu8slice ser_ref;
29627 ser_ref.datalen = ser->arr_len;
29628 ser_ref.data = ser->elems;
29629 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
29630 *ret_conv = CounterpartyForwardingInfo_read(ser_ref);
29632 return tag_ptr(ret_conv, true);
29635 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_write"))) TS_ChannelCounterparty_write(uint64_t obj) {
29636 LDKChannelCounterparty obj_conv;
29637 obj_conv.inner = untag_ptr(obj);
29638 obj_conv.is_owned = ptr_is_owned(obj);
29639 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29640 obj_conv.is_owned = false;
29641 LDKCVec_u8Z ret_var = ChannelCounterparty_write(&obj_conv);
29642 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29643 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29644 CVec_u8Z_free(ret_var);
29648 uint64_t __attribute__((export_name("TS_ChannelCounterparty_read"))) TS_ChannelCounterparty_read(int8_tArray ser) {
29649 LDKu8slice ser_ref;
29650 ser_ref.datalen = ser->arr_len;
29651 ser_ref.data = ser->elems;
29652 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
29653 *ret_conv = ChannelCounterparty_read(ser_ref);
29655 return tag_ptr(ret_conv, true);
29658 int8_tArray __attribute__((export_name("TS_ChannelDetails_write"))) TS_ChannelDetails_write(uint64_t obj) {
29659 LDKChannelDetails obj_conv;
29660 obj_conv.inner = untag_ptr(obj);
29661 obj_conv.is_owned = ptr_is_owned(obj);
29662 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29663 obj_conv.is_owned = false;
29664 LDKCVec_u8Z ret_var = ChannelDetails_write(&obj_conv);
29665 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29666 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29667 CVec_u8Z_free(ret_var);
29671 uint64_t __attribute__((export_name("TS_ChannelDetails_read"))) TS_ChannelDetails_read(int8_tArray ser) {
29672 LDKu8slice ser_ref;
29673 ser_ref.datalen = ser->arr_len;
29674 ser_ref.data = ser->elems;
29675 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
29676 *ret_conv = ChannelDetails_read(ser_ref);
29678 return tag_ptr(ret_conv, true);
29681 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_write"))) TS_PhantomRouteHints_write(uint64_t obj) {
29682 LDKPhantomRouteHints obj_conv;
29683 obj_conv.inner = untag_ptr(obj);
29684 obj_conv.is_owned = ptr_is_owned(obj);
29685 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29686 obj_conv.is_owned = false;
29687 LDKCVec_u8Z ret_var = PhantomRouteHints_write(&obj_conv);
29688 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29689 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29690 CVec_u8Z_free(ret_var);
29694 uint64_t __attribute__((export_name("TS_PhantomRouteHints_read"))) TS_PhantomRouteHints_read(int8_tArray ser) {
29695 LDKu8slice ser_ref;
29696 ser_ref.datalen = ser->arr_len;
29697 ser_ref.data = ser->elems;
29698 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
29699 *ret_conv = PhantomRouteHints_read(ser_ref);
29701 return tag_ptr(ret_conv, true);
29704 int8_tArray __attribute__((export_name("TS_ChannelManager_write"))) TS_ChannelManager_write(uint64_t obj) {
29705 LDKChannelManager obj_conv;
29706 obj_conv.inner = untag_ptr(obj);
29707 obj_conv.is_owned = ptr_is_owned(obj);
29708 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29709 obj_conv.is_owned = false;
29710 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
29711 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29712 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29713 CVec_u8Z_free(ret_var);
29717 void __attribute__((export_name("TS_ChannelManagerReadArgs_free"))) TS_ChannelManagerReadArgs_free(uint64_t this_obj) {
29718 LDKChannelManagerReadArgs this_obj_conv;
29719 this_obj_conv.inner = untag_ptr(this_obj);
29720 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29722 ChannelManagerReadArgs_free(this_obj_conv);
29725 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_entropy_source"))) TS_ChannelManagerReadArgs_get_entropy_source(uint64_t this_ptr) {
29726 LDKChannelManagerReadArgs this_ptr_conv;
29727 this_ptr_conv.inner = untag_ptr(this_ptr);
29728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29730 this_ptr_conv.is_owned = false;
29731 // WARNING: This object doesn't live past this scope, needs clone!
29732 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_entropy_source(&this_ptr_conv), false);
29736 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_entropy_source"))) TS_ChannelManagerReadArgs_set_entropy_source(uint64_t this_ptr, uint64_t val) {
29737 LDKChannelManagerReadArgs this_ptr_conv;
29738 this_ptr_conv.inner = untag_ptr(this_ptr);
29739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29741 this_ptr_conv.is_owned = false;
29742 void* val_ptr = untag_ptr(val);
29743 CHECK_ACCESS(val_ptr);
29744 LDKEntropySource val_conv = *(LDKEntropySource*)(val_ptr);
29745 if (val_conv.free == LDKEntropySource_JCalls_free) {
29746 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29747 LDKEntropySource_JCalls_cloned(&val_conv);
29749 ChannelManagerReadArgs_set_entropy_source(&this_ptr_conv, val_conv);
29752 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_node_signer"))) TS_ChannelManagerReadArgs_get_node_signer(uint64_t this_ptr) {
29753 LDKChannelManagerReadArgs this_ptr_conv;
29754 this_ptr_conv.inner = untag_ptr(this_ptr);
29755 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29756 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29757 this_ptr_conv.is_owned = false;
29758 // WARNING: This object doesn't live past this scope, needs clone!
29759 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_node_signer(&this_ptr_conv), false);
29763 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_node_signer"))) TS_ChannelManagerReadArgs_set_node_signer(uint64_t this_ptr, uint64_t val) {
29764 LDKChannelManagerReadArgs this_ptr_conv;
29765 this_ptr_conv.inner = untag_ptr(this_ptr);
29766 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29767 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29768 this_ptr_conv.is_owned = false;
29769 void* val_ptr = untag_ptr(val);
29770 CHECK_ACCESS(val_ptr);
29771 LDKNodeSigner val_conv = *(LDKNodeSigner*)(val_ptr);
29772 if (val_conv.free == LDKNodeSigner_JCalls_free) {
29773 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29774 LDKNodeSigner_JCalls_cloned(&val_conv);
29776 ChannelManagerReadArgs_set_node_signer(&this_ptr_conv, val_conv);
29779 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_signer_provider"))) TS_ChannelManagerReadArgs_get_signer_provider(uint64_t this_ptr) {
29780 LDKChannelManagerReadArgs this_ptr_conv;
29781 this_ptr_conv.inner = untag_ptr(this_ptr);
29782 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29783 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29784 this_ptr_conv.is_owned = false;
29785 // WARNING: This object doesn't live past this scope, needs clone!
29786 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_signer_provider(&this_ptr_conv), false);
29790 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_signer_provider"))) TS_ChannelManagerReadArgs_set_signer_provider(uint64_t this_ptr, uint64_t val) {
29791 LDKChannelManagerReadArgs this_ptr_conv;
29792 this_ptr_conv.inner = untag_ptr(this_ptr);
29793 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29795 this_ptr_conv.is_owned = false;
29796 void* val_ptr = untag_ptr(val);
29797 CHECK_ACCESS(val_ptr);
29798 LDKSignerProvider val_conv = *(LDKSignerProvider*)(val_ptr);
29799 if (val_conv.free == LDKSignerProvider_JCalls_free) {
29800 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29801 LDKSignerProvider_JCalls_cloned(&val_conv);
29803 ChannelManagerReadArgs_set_signer_provider(&this_ptr_conv, val_conv);
29806 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_fee_estimator"))) TS_ChannelManagerReadArgs_get_fee_estimator(uint64_t this_ptr) {
29807 LDKChannelManagerReadArgs this_ptr_conv;
29808 this_ptr_conv.inner = untag_ptr(this_ptr);
29809 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29811 this_ptr_conv.is_owned = false;
29812 // WARNING: This object doesn't live past this scope, needs clone!
29813 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv), false);
29817 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_fee_estimator"))) TS_ChannelManagerReadArgs_set_fee_estimator(uint64_t this_ptr, uint64_t val) {
29818 LDKChannelManagerReadArgs this_ptr_conv;
29819 this_ptr_conv.inner = untag_ptr(this_ptr);
29820 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29822 this_ptr_conv.is_owned = false;
29823 void* val_ptr = untag_ptr(val);
29824 CHECK_ACCESS(val_ptr);
29825 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
29826 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
29827 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29828 LDKFeeEstimator_JCalls_cloned(&val_conv);
29830 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
29833 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_chain_monitor"))) TS_ChannelManagerReadArgs_get_chain_monitor(uint64_t this_ptr) {
29834 LDKChannelManagerReadArgs this_ptr_conv;
29835 this_ptr_conv.inner = untag_ptr(this_ptr);
29836 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29837 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29838 this_ptr_conv.is_owned = false;
29839 // WARNING: This object doesn't live past this scope, needs clone!
29840 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv), false);
29844 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_chain_monitor"))) TS_ChannelManagerReadArgs_set_chain_monitor(uint64_t this_ptr, uint64_t val) {
29845 LDKChannelManagerReadArgs this_ptr_conv;
29846 this_ptr_conv.inner = untag_ptr(this_ptr);
29847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29849 this_ptr_conv.is_owned = false;
29850 void* val_ptr = untag_ptr(val);
29851 CHECK_ACCESS(val_ptr);
29852 LDKWatch val_conv = *(LDKWatch*)(val_ptr);
29853 if (val_conv.free == LDKWatch_JCalls_free) {
29854 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29855 LDKWatch_JCalls_cloned(&val_conv);
29857 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
29860 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_tx_broadcaster"))) TS_ChannelManagerReadArgs_get_tx_broadcaster(uint64_t this_ptr) {
29861 LDKChannelManagerReadArgs this_ptr_conv;
29862 this_ptr_conv.inner = untag_ptr(this_ptr);
29863 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29865 this_ptr_conv.is_owned = false;
29866 // WARNING: This object doesn't live past this scope, needs clone!
29867 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv), false);
29871 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_tx_broadcaster"))) TS_ChannelManagerReadArgs_set_tx_broadcaster(uint64_t this_ptr, uint64_t val) {
29872 LDKChannelManagerReadArgs this_ptr_conv;
29873 this_ptr_conv.inner = untag_ptr(this_ptr);
29874 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29876 this_ptr_conv.is_owned = false;
29877 void* val_ptr = untag_ptr(val);
29878 CHECK_ACCESS(val_ptr);
29879 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
29880 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
29881 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29882 LDKBroadcasterInterface_JCalls_cloned(&val_conv);
29884 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
29887 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_router"))) TS_ChannelManagerReadArgs_get_router(uint64_t this_ptr) {
29888 LDKChannelManagerReadArgs this_ptr_conv;
29889 this_ptr_conv.inner = untag_ptr(this_ptr);
29890 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29891 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29892 this_ptr_conv.is_owned = false;
29893 // WARNING: This object doesn't live past this scope, needs clone!
29894 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_router(&this_ptr_conv), false);
29898 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_router"))) TS_ChannelManagerReadArgs_set_router(uint64_t this_ptr, uint64_t val) {
29899 LDKChannelManagerReadArgs this_ptr_conv;
29900 this_ptr_conv.inner = untag_ptr(this_ptr);
29901 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29902 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29903 this_ptr_conv.is_owned = false;
29904 void* val_ptr = untag_ptr(val);
29905 CHECK_ACCESS(val_ptr);
29906 LDKRouter val_conv = *(LDKRouter*)(val_ptr);
29907 if (val_conv.free == LDKRouter_JCalls_free) {
29908 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29909 LDKRouter_JCalls_cloned(&val_conv);
29911 ChannelManagerReadArgs_set_router(&this_ptr_conv, val_conv);
29914 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_logger"))) TS_ChannelManagerReadArgs_get_logger(uint64_t this_ptr) {
29915 LDKChannelManagerReadArgs this_ptr_conv;
29916 this_ptr_conv.inner = untag_ptr(this_ptr);
29917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29919 this_ptr_conv.is_owned = false;
29920 // WARNING: This object doesn't live past this scope, needs clone!
29921 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_logger(&this_ptr_conv), false);
29925 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_logger"))) TS_ChannelManagerReadArgs_set_logger(uint64_t this_ptr, uint64_t val) {
29926 LDKChannelManagerReadArgs this_ptr_conv;
29927 this_ptr_conv.inner = untag_ptr(this_ptr);
29928 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29930 this_ptr_conv.is_owned = false;
29931 void* val_ptr = untag_ptr(val);
29932 CHECK_ACCESS(val_ptr);
29933 LDKLogger val_conv = *(LDKLogger*)(val_ptr);
29934 if (val_conv.free == LDKLogger_JCalls_free) {
29935 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29936 LDKLogger_JCalls_cloned(&val_conv);
29938 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
29941 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_default_config"))) TS_ChannelManagerReadArgs_get_default_config(uint64_t this_ptr) {
29942 LDKChannelManagerReadArgs this_ptr_conv;
29943 this_ptr_conv.inner = untag_ptr(this_ptr);
29944 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29946 this_ptr_conv.is_owned = false;
29947 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
29948 uint64_t ret_ref = 0;
29949 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29950 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29954 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_default_config"))) TS_ChannelManagerReadArgs_set_default_config(uint64_t this_ptr, uint64_t val) {
29955 LDKChannelManagerReadArgs this_ptr_conv;
29956 this_ptr_conv.inner = untag_ptr(this_ptr);
29957 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29959 this_ptr_conv.is_owned = false;
29960 LDKUserConfig val_conv;
29961 val_conv.inner = untag_ptr(val);
29962 val_conv.is_owned = ptr_is_owned(val);
29963 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
29964 val_conv = UserConfig_clone(&val_conv);
29965 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
29968 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_new"))) TS_ChannelManagerReadArgs_new(uint64_t entropy_source, uint64_t node_signer, uint64_t signer_provider, uint64_t fee_estimator, uint64_t chain_monitor, uint64_t tx_broadcaster, uint64_t router, uint64_t logger, uint64_t default_config, uint64_tArray channel_monitors) {
29969 void* entropy_source_ptr = untag_ptr(entropy_source);
29970 CHECK_ACCESS(entropy_source_ptr);
29971 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
29972 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
29973 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29974 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
29976 void* node_signer_ptr = untag_ptr(node_signer);
29977 CHECK_ACCESS(node_signer_ptr);
29978 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
29979 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
29980 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29981 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
29983 void* signer_provider_ptr = untag_ptr(signer_provider);
29984 CHECK_ACCESS(signer_provider_ptr);
29985 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
29986 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
29987 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29988 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
29990 void* fee_estimator_ptr = untag_ptr(fee_estimator);
29991 CHECK_ACCESS(fee_estimator_ptr);
29992 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
29993 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
29994 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29995 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
29997 void* chain_monitor_ptr = untag_ptr(chain_monitor);
29998 CHECK_ACCESS(chain_monitor_ptr);
29999 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
30000 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
30001 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30002 LDKWatch_JCalls_cloned(&chain_monitor_conv);
30004 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
30005 CHECK_ACCESS(tx_broadcaster_ptr);
30006 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
30007 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
30008 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30009 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
30011 void* router_ptr = untag_ptr(router);
30012 CHECK_ACCESS(router_ptr);
30013 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
30014 if (router_conv.free == LDKRouter_JCalls_free) {
30015 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30016 LDKRouter_JCalls_cloned(&router_conv);
30018 void* logger_ptr = untag_ptr(logger);
30019 CHECK_ACCESS(logger_ptr);
30020 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
30021 if (logger_conv.free == LDKLogger_JCalls_free) {
30022 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30023 LDKLogger_JCalls_cloned(&logger_conv);
30025 LDKUserConfig default_config_conv;
30026 default_config_conv.inner = untag_ptr(default_config);
30027 default_config_conv.is_owned = ptr_is_owned(default_config);
30028 CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
30029 default_config_conv = UserConfig_clone(&default_config_conv);
30030 LDKCVec_ChannelMonitorZ channel_monitors_constr;
30031 channel_monitors_constr.datalen = channel_monitors->arr_len;
30032 if (channel_monitors_constr.datalen > 0)
30033 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
30035 channel_monitors_constr.data = NULL;
30036 uint64_t* channel_monitors_vals = channel_monitors->elems;
30037 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
30038 uint64_t channel_monitors_conv_16 = channel_monitors_vals[q];
30039 LDKChannelMonitor channel_monitors_conv_16_conv;
30040 channel_monitors_conv_16_conv.inner = untag_ptr(channel_monitors_conv_16);
30041 channel_monitors_conv_16_conv.is_owned = ptr_is_owned(channel_monitors_conv_16);
30042 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
30043 channel_monitors_conv_16_conv.is_owned = false;
30044 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
30046 FREE(channel_monitors);
30047 LDKChannelManagerReadArgs ret_var = ChannelManagerReadArgs_new(entropy_source_conv, node_signer_conv, signer_provider_conv, fee_estimator_conv, chain_monitor_conv, tx_broadcaster_conv, router_conv, logger_conv, default_config_conv, channel_monitors_constr);
30048 uint64_t ret_ref = 0;
30049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30054 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_read"))) TS_C2Tuple_BlockHashChannelManagerZ_read(int8_tArray ser, uint64_t arg) {
30055 LDKu8slice ser_ref;
30056 ser_ref.datalen = ser->arr_len;
30057 ser_ref.data = ser->elems;
30058 LDKChannelManagerReadArgs arg_conv;
30059 arg_conv.inner = untag_ptr(arg);
30060 arg_conv.is_owned = ptr_is_owned(arg);
30061 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30062 // WARNING: we need a move here but no clone is available for LDKChannelManagerReadArgs
30064 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
30065 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
30067 return tag_ptr(ret_conv, true);
30070 void __attribute__((export_name("TS_ExpandedKey_free"))) TS_ExpandedKey_free(uint64_t this_obj) {
30071 LDKExpandedKey this_obj_conv;
30072 this_obj_conv.inner = untag_ptr(this_obj);
30073 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30075 ExpandedKey_free(this_obj_conv);
30078 uint64_t __attribute__((export_name("TS_ExpandedKey_new"))) TS_ExpandedKey_new(int8_tArray key_material) {
30079 uint8_t key_material_arr[32];
30080 CHECK(key_material->arr_len == 32);
30081 memcpy(key_material_arr, key_material->elems, 32); FREE(key_material);
30082 uint8_t (*key_material_ref)[32] = &key_material_arr;
30083 LDKExpandedKey ret_var = ExpandedKey_new(key_material_ref);
30084 uint64_t ret_ref = 0;
30085 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30086 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30090 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 entropy_source, int64_t current_time, uint64_t min_final_cltv_expiry_delta) {
30091 LDKExpandedKey keys_conv;
30092 keys_conv.inner = untag_ptr(keys);
30093 keys_conv.is_owned = ptr_is_owned(keys);
30094 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
30095 keys_conv.is_owned = false;
30096 void* min_value_msat_ptr = untag_ptr(min_value_msat);
30097 CHECK_ACCESS(min_value_msat_ptr);
30098 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
30099 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
30100 void* entropy_source_ptr = untag_ptr(entropy_source);
30101 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
30102 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
30103 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
30104 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
30105 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
30106 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
30107 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
30108 *ret_conv = create(&keys_conv, min_value_msat_conv, invoice_expiry_delta_secs, entropy_source_conv, current_time, min_final_cltv_expiry_delta_conv);
30109 return tag_ptr(ret_conv, true);
30112 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, uint64_t min_final_cltv_expiry_delta) {
30113 LDKExpandedKey keys_conv;
30114 keys_conv.inner = untag_ptr(keys);
30115 keys_conv.is_owned = ptr_is_owned(keys);
30116 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
30117 keys_conv.is_owned = false;
30118 void* min_value_msat_ptr = untag_ptr(min_value_msat);
30119 CHECK_ACCESS(min_value_msat_ptr);
30120 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
30121 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
30122 LDKThirtyTwoBytes payment_hash_ref;
30123 CHECK(payment_hash->arr_len == 32);
30124 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
30125 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
30126 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
30127 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
30128 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
30129 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
30130 *ret_conv = create_from_hash(&keys_conv, min_value_msat_conv, payment_hash_ref, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta_conv);
30131 return tag_ptr(ret_conv, true);
30134 void __attribute__((export_name("TS_DecodeError_free"))) TS_DecodeError_free(uint64_t this_ptr) {
30135 if (!ptr_is_owned(this_ptr)) return;
30136 void* this_ptr_ptr = untag_ptr(this_ptr);
30137 CHECK_ACCESS(this_ptr_ptr);
30138 LDKDecodeError this_ptr_conv = *(LDKDecodeError*)(this_ptr_ptr);
30139 FREE(untag_ptr(this_ptr));
30140 DecodeError_free(this_ptr_conv);
30143 static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
30144 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30145 *ret_copy = DecodeError_clone(arg);
30146 uint64_t ret_ref = tag_ptr(ret_copy, true);
30149 int64_t __attribute__((export_name("TS_DecodeError_clone_ptr"))) TS_DecodeError_clone_ptr(uint64_t arg) {
30150 LDKDecodeError* arg_conv = (LDKDecodeError*)untag_ptr(arg);
30151 int64_t ret_conv = DecodeError_clone_ptr(arg_conv);
30155 uint64_t __attribute__((export_name("TS_DecodeError_clone"))) TS_DecodeError_clone(uint64_t orig) {
30156 LDKDecodeError* orig_conv = (LDKDecodeError*)untag_ptr(orig);
30157 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30158 *ret_copy = DecodeError_clone(orig_conv);
30159 uint64_t ret_ref = tag_ptr(ret_copy, true);
30163 uint64_t __attribute__((export_name("TS_DecodeError_unknown_version"))) TS_DecodeError_unknown_version() {
30164 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30165 *ret_copy = DecodeError_unknown_version();
30166 uint64_t ret_ref = tag_ptr(ret_copy, true);
30170 uint64_t __attribute__((export_name("TS_DecodeError_unknown_required_feature"))) TS_DecodeError_unknown_required_feature() {
30171 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30172 *ret_copy = DecodeError_unknown_required_feature();
30173 uint64_t ret_ref = tag_ptr(ret_copy, true);
30177 uint64_t __attribute__((export_name("TS_DecodeError_invalid_value"))) TS_DecodeError_invalid_value() {
30178 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30179 *ret_copy = DecodeError_invalid_value();
30180 uint64_t ret_ref = tag_ptr(ret_copy, true);
30184 uint64_t __attribute__((export_name("TS_DecodeError_short_read"))) TS_DecodeError_short_read() {
30185 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30186 *ret_copy = DecodeError_short_read();
30187 uint64_t ret_ref = tag_ptr(ret_copy, true);
30191 uint64_t __attribute__((export_name("TS_DecodeError_bad_length_descriptor"))) TS_DecodeError_bad_length_descriptor() {
30192 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30193 *ret_copy = DecodeError_bad_length_descriptor();
30194 uint64_t ret_ref = tag_ptr(ret_copy, true);
30198 uint64_t __attribute__((export_name("TS_DecodeError_io"))) TS_DecodeError_io(uint32_t a) {
30199 LDKIOError a_conv = LDKIOError_from_js(a);
30200 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30201 *ret_copy = DecodeError_io(a_conv);
30202 uint64_t ret_ref = tag_ptr(ret_copy, true);
30206 uint64_t __attribute__((export_name("TS_DecodeError_unsupported_compression"))) TS_DecodeError_unsupported_compression() {
30207 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30208 *ret_copy = DecodeError_unsupported_compression();
30209 uint64_t ret_ref = tag_ptr(ret_copy, true);
30213 jboolean __attribute__((export_name("TS_DecodeError_eq"))) TS_DecodeError_eq(uint64_t a, uint64_t b) {
30214 LDKDecodeError* a_conv = (LDKDecodeError*)untag_ptr(a);
30215 LDKDecodeError* b_conv = (LDKDecodeError*)untag_ptr(b);
30216 jboolean ret_conv = DecodeError_eq(a_conv, b_conv);
30220 void __attribute__((export_name("TS_Init_free"))) TS_Init_free(uint64_t this_obj) {
30221 LDKInit this_obj_conv;
30222 this_obj_conv.inner = untag_ptr(this_obj);
30223 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30225 Init_free(this_obj_conv);
30228 uint64_t __attribute__((export_name("TS_Init_get_features"))) TS_Init_get_features(uint64_t this_ptr) {
30229 LDKInit 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 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
30235 uint64_t ret_ref = 0;
30236 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30237 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30241 void __attribute__((export_name("TS_Init_set_features"))) TS_Init_set_features(uint64_t this_ptr, uint64_t val) {
30242 LDKInit this_ptr_conv;
30243 this_ptr_conv.inner = untag_ptr(this_ptr);
30244 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30246 this_ptr_conv.is_owned = false;
30247 LDKInitFeatures val_conv;
30248 val_conv.inner = untag_ptr(val);
30249 val_conv.is_owned = ptr_is_owned(val);
30250 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
30251 val_conv = InitFeatures_clone(&val_conv);
30252 Init_set_features(&this_ptr_conv, val_conv);
30255 uint64_t __attribute__((export_name("TS_Init_get_remote_network_address"))) TS_Init_get_remote_network_address(uint64_t this_ptr) {
30256 LDKInit this_ptr_conv;
30257 this_ptr_conv.inner = untag_ptr(this_ptr);
30258 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30260 this_ptr_conv.is_owned = false;
30261 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
30262 *ret_copy = Init_get_remote_network_address(&this_ptr_conv);
30263 uint64_t ret_ref = tag_ptr(ret_copy, true);
30267 void __attribute__((export_name("TS_Init_set_remote_network_address"))) TS_Init_set_remote_network_address(uint64_t this_ptr, uint64_t val) {
30268 LDKInit this_ptr_conv;
30269 this_ptr_conv.inner = untag_ptr(this_ptr);
30270 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30272 this_ptr_conv.is_owned = false;
30273 void* val_ptr = untag_ptr(val);
30274 CHECK_ACCESS(val_ptr);
30275 LDKCOption_NetAddressZ val_conv = *(LDKCOption_NetAddressZ*)(val_ptr);
30276 val_conv = COption_NetAddressZ_clone((LDKCOption_NetAddressZ*)untag_ptr(val));
30277 Init_set_remote_network_address(&this_ptr_conv, val_conv);
30280 uint64_t __attribute__((export_name("TS_Init_new"))) TS_Init_new(uint64_t features_arg, uint64_t remote_network_address_arg) {
30281 LDKInitFeatures features_arg_conv;
30282 features_arg_conv.inner = untag_ptr(features_arg);
30283 features_arg_conv.is_owned = ptr_is_owned(features_arg);
30284 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
30285 features_arg_conv = InitFeatures_clone(&features_arg_conv);
30286 void* remote_network_address_arg_ptr = untag_ptr(remote_network_address_arg);
30287 CHECK_ACCESS(remote_network_address_arg_ptr);
30288 LDKCOption_NetAddressZ remote_network_address_arg_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_arg_ptr);
30289 LDKInit ret_var = Init_new(features_arg_conv, remote_network_address_arg_conv);
30290 uint64_t ret_ref = 0;
30291 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30292 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30296 static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
30297 LDKInit ret_var = Init_clone(arg);
30298 uint64_t ret_ref = 0;
30299 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30300 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30303 int64_t __attribute__((export_name("TS_Init_clone_ptr"))) TS_Init_clone_ptr(uint64_t arg) {
30305 arg_conv.inner = untag_ptr(arg);
30306 arg_conv.is_owned = ptr_is_owned(arg);
30307 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30308 arg_conv.is_owned = false;
30309 int64_t ret_conv = Init_clone_ptr(&arg_conv);
30313 uint64_t __attribute__((export_name("TS_Init_clone"))) TS_Init_clone(uint64_t orig) {
30315 orig_conv.inner = untag_ptr(orig);
30316 orig_conv.is_owned = ptr_is_owned(orig);
30317 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30318 orig_conv.is_owned = false;
30319 LDKInit ret_var = Init_clone(&orig_conv);
30320 uint64_t ret_ref = 0;
30321 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30322 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30326 jboolean __attribute__((export_name("TS_Init_eq"))) TS_Init_eq(uint64_t a, uint64_t b) {
30328 a_conv.inner = untag_ptr(a);
30329 a_conv.is_owned = ptr_is_owned(a);
30330 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30331 a_conv.is_owned = false;
30333 b_conv.inner = untag_ptr(b);
30334 b_conv.is_owned = ptr_is_owned(b);
30335 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30336 b_conv.is_owned = false;
30337 jboolean ret_conv = Init_eq(&a_conv, &b_conv);
30341 void __attribute__((export_name("TS_ErrorMessage_free"))) TS_ErrorMessage_free(uint64_t this_obj) {
30342 LDKErrorMessage this_obj_conv;
30343 this_obj_conv.inner = untag_ptr(this_obj);
30344 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30346 ErrorMessage_free(this_obj_conv);
30349 int8_tArray __attribute__((export_name("TS_ErrorMessage_get_channel_id"))) TS_ErrorMessage_get_channel_id(uint64_t this_ptr) {
30350 LDKErrorMessage this_ptr_conv;
30351 this_ptr_conv.inner = untag_ptr(this_ptr);
30352 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30354 this_ptr_conv.is_owned = false;
30355 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30356 memcpy(ret_arr->elems, *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
30360 void __attribute__((export_name("TS_ErrorMessage_set_channel_id"))) TS_ErrorMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
30361 LDKErrorMessage this_ptr_conv;
30362 this_ptr_conv.inner = untag_ptr(this_ptr);
30363 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30365 this_ptr_conv.is_owned = false;
30366 LDKThirtyTwoBytes val_ref;
30367 CHECK(val->arr_len == 32);
30368 memcpy(val_ref.data, val->elems, 32); FREE(val);
30369 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
30372 jstring __attribute__((export_name("TS_ErrorMessage_get_data"))) TS_ErrorMessage_get_data(uint64_t this_ptr) {
30373 LDKErrorMessage this_ptr_conv;
30374 this_ptr_conv.inner = untag_ptr(this_ptr);
30375 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30377 this_ptr_conv.is_owned = false;
30378 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
30379 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
30384 void __attribute__((export_name("TS_ErrorMessage_set_data"))) TS_ErrorMessage_set_data(uint64_t this_ptr, jstring val) {
30385 LDKErrorMessage this_ptr_conv;
30386 this_ptr_conv.inner = untag_ptr(this_ptr);
30387 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30388 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30389 this_ptr_conv.is_owned = false;
30390 LDKStr val_conv = str_ref_to_owned_c(val);
30391 ErrorMessage_set_data(&this_ptr_conv, val_conv);
30394 uint64_t __attribute__((export_name("TS_ErrorMessage_new"))) TS_ErrorMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
30395 LDKThirtyTwoBytes channel_id_arg_ref;
30396 CHECK(channel_id_arg->arr_len == 32);
30397 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30398 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
30399 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
30400 uint64_t ret_ref = 0;
30401 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30402 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30406 static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
30407 LDKErrorMessage ret_var = ErrorMessage_clone(arg);
30408 uint64_t ret_ref = 0;
30409 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30410 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30413 int64_t __attribute__((export_name("TS_ErrorMessage_clone_ptr"))) TS_ErrorMessage_clone_ptr(uint64_t arg) {
30414 LDKErrorMessage arg_conv;
30415 arg_conv.inner = untag_ptr(arg);
30416 arg_conv.is_owned = ptr_is_owned(arg);
30417 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30418 arg_conv.is_owned = false;
30419 int64_t ret_conv = ErrorMessage_clone_ptr(&arg_conv);
30423 uint64_t __attribute__((export_name("TS_ErrorMessage_clone"))) TS_ErrorMessage_clone(uint64_t orig) {
30424 LDKErrorMessage orig_conv;
30425 orig_conv.inner = untag_ptr(orig);
30426 orig_conv.is_owned = ptr_is_owned(orig);
30427 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30428 orig_conv.is_owned = false;
30429 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
30430 uint64_t ret_ref = 0;
30431 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30432 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30436 jboolean __attribute__((export_name("TS_ErrorMessage_eq"))) TS_ErrorMessage_eq(uint64_t a, uint64_t b) {
30437 LDKErrorMessage a_conv;
30438 a_conv.inner = untag_ptr(a);
30439 a_conv.is_owned = ptr_is_owned(a);
30440 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30441 a_conv.is_owned = false;
30442 LDKErrorMessage b_conv;
30443 b_conv.inner = untag_ptr(b);
30444 b_conv.is_owned = ptr_is_owned(b);
30445 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30446 b_conv.is_owned = false;
30447 jboolean ret_conv = ErrorMessage_eq(&a_conv, &b_conv);
30451 void __attribute__((export_name("TS_WarningMessage_free"))) TS_WarningMessage_free(uint64_t this_obj) {
30452 LDKWarningMessage this_obj_conv;
30453 this_obj_conv.inner = untag_ptr(this_obj);
30454 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30456 WarningMessage_free(this_obj_conv);
30459 int8_tArray __attribute__((export_name("TS_WarningMessage_get_channel_id"))) TS_WarningMessage_get_channel_id(uint64_t this_ptr) {
30460 LDKWarningMessage this_ptr_conv;
30461 this_ptr_conv.inner = untag_ptr(this_ptr);
30462 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30463 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30464 this_ptr_conv.is_owned = false;
30465 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30466 memcpy(ret_arr->elems, *WarningMessage_get_channel_id(&this_ptr_conv), 32);
30470 void __attribute__((export_name("TS_WarningMessage_set_channel_id"))) TS_WarningMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
30471 LDKWarningMessage 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 LDKThirtyTwoBytes val_ref;
30477 CHECK(val->arr_len == 32);
30478 memcpy(val_ref.data, val->elems, 32); FREE(val);
30479 WarningMessage_set_channel_id(&this_ptr_conv, val_ref);
30482 jstring __attribute__((export_name("TS_WarningMessage_get_data"))) TS_WarningMessage_get_data(uint64_t this_ptr) {
30483 LDKWarningMessage this_ptr_conv;
30484 this_ptr_conv.inner = untag_ptr(this_ptr);
30485 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30487 this_ptr_conv.is_owned = false;
30488 LDKStr ret_str = WarningMessage_get_data(&this_ptr_conv);
30489 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
30494 void __attribute__((export_name("TS_WarningMessage_set_data"))) TS_WarningMessage_set_data(uint64_t this_ptr, jstring val) {
30495 LDKWarningMessage this_ptr_conv;
30496 this_ptr_conv.inner = untag_ptr(this_ptr);
30497 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30499 this_ptr_conv.is_owned = false;
30500 LDKStr val_conv = str_ref_to_owned_c(val);
30501 WarningMessage_set_data(&this_ptr_conv, val_conv);
30504 uint64_t __attribute__((export_name("TS_WarningMessage_new"))) TS_WarningMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
30505 LDKThirtyTwoBytes channel_id_arg_ref;
30506 CHECK(channel_id_arg->arr_len == 32);
30507 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30508 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
30509 LDKWarningMessage ret_var = WarningMessage_new(channel_id_arg_ref, data_arg_conv);
30510 uint64_t ret_ref = 0;
30511 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30512 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30516 static inline uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg) {
30517 LDKWarningMessage ret_var = WarningMessage_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_WarningMessage_clone_ptr"))) TS_WarningMessage_clone_ptr(uint64_t arg) {
30524 LDKWarningMessage 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 = WarningMessage_clone_ptr(&arg_conv);
30533 uint64_t __attribute__((export_name("TS_WarningMessage_clone"))) TS_WarningMessage_clone(uint64_t orig) {
30534 LDKWarningMessage 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 LDKWarningMessage ret_var = WarningMessage_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_WarningMessage_eq"))) TS_WarningMessage_eq(uint64_t a, uint64_t b) {
30547 LDKWarningMessage 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 LDKWarningMessage 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 = WarningMessage_eq(&a_conv, &b_conv);
30561 void __attribute__((export_name("TS_Ping_free"))) TS_Ping_free(uint64_t this_obj) {
30562 LDKPing 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 Ping_free(this_obj_conv);
30569 int16_t __attribute__((export_name("TS_Ping_get_ponglen"))) TS_Ping_get_ponglen(uint64_t this_ptr) {
30570 LDKPing 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 int16_t ret_conv = Ping_get_ponglen(&this_ptr_conv);
30579 void __attribute__((export_name("TS_Ping_set_ponglen"))) TS_Ping_set_ponglen(uint64_t this_ptr, int16_t val) {
30580 LDKPing this_ptr_conv;
30581 this_ptr_conv.inner = untag_ptr(this_ptr);
30582 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30584 this_ptr_conv.is_owned = false;
30585 Ping_set_ponglen(&this_ptr_conv, val);
30588 int16_t __attribute__((export_name("TS_Ping_get_byteslen"))) TS_Ping_get_byteslen(uint64_t this_ptr) {
30589 LDKPing this_ptr_conv;
30590 this_ptr_conv.inner = untag_ptr(this_ptr);
30591 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30593 this_ptr_conv.is_owned = false;
30594 int16_t ret_conv = Ping_get_byteslen(&this_ptr_conv);
30598 void __attribute__((export_name("TS_Ping_set_byteslen"))) TS_Ping_set_byteslen(uint64_t this_ptr, int16_t val) {
30599 LDKPing this_ptr_conv;
30600 this_ptr_conv.inner = untag_ptr(this_ptr);
30601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30603 this_ptr_conv.is_owned = false;
30604 Ping_set_byteslen(&this_ptr_conv, val);
30607 uint64_t __attribute__((export_name("TS_Ping_new"))) TS_Ping_new(int16_t ponglen_arg, int16_t byteslen_arg) {
30608 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
30609 uint64_t ret_ref = 0;
30610 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30611 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30615 static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
30616 LDKPing ret_var = Ping_clone(arg);
30617 uint64_t ret_ref = 0;
30618 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30619 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30622 int64_t __attribute__((export_name("TS_Ping_clone_ptr"))) TS_Ping_clone_ptr(uint64_t arg) {
30624 arg_conv.inner = untag_ptr(arg);
30625 arg_conv.is_owned = ptr_is_owned(arg);
30626 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30627 arg_conv.is_owned = false;
30628 int64_t ret_conv = Ping_clone_ptr(&arg_conv);
30632 uint64_t __attribute__((export_name("TS_Ping_clone"))) TS_Ping_clone(uint64_t orig) {
30634 orig_conv.inner = untag_ptr(orig);
30635 orig_conv.is_owned = ptr_is_owned(orig);
30636 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30637 orig_conv.is_owned = false;
30638 LDKPing ret_var = Ping_clone(&orig_conv);
30639 uint64_t ret_ref = 0;
30640 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30641 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30645 jboolean __attribute__((export_name("TS_Ping_eq"))) TS_Ping_eq(uint64_t a, uint64_t b) {
30647 a_conv.inner = untag_ptr(a);
30648 a_conv.is_owned = ptr_is_owned(a);
30649 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30650 a_conv.is_owned = false;
30652 b_conv.inner = untag_ptr(b);
30653 b_conv.is_owned = ptr_is_owned(b);
30654 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30655 b_conv.is_owned = false;
30656 jboolean ret_conv = Ping_eq(&a_conv, &b_conv);
30660 void __attribute__((export_name("TS_Pong_free"))) TS_Pong_free(uint64_t this_obj) {
30661 LDKPong this_obj_conv;
30662 this_obj_conv.inner = untag_ptr(this_obj);
30663 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30664 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30665 Pong_free(this_obj_conv);
30668 int16_t __attribute__((export_name("TS_Pong_get_byteslen"))) TS_Pong_get_byteslen(uint64_t this_ptr) {
30669 LDKPong 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 int16_t ret_conv = Pong_get_byteslen(&this_ptr_conv);
30678 void __attribute__((export_name("TS_Pong_set_byteslen"))) TS_Pong_set_byteslen(uint64_t this_ptr, int16_t val) {
30679 LDKPong 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 Pong_set_byteslen(&this_ptr_conv, val);
30687 uint64_t __attribute__((export_name("TS_Pong_new"))) TS_Pong_new(int16_t byteslen_arg) {
30688 LDKPong ret_var = Pong_new(byteslen_arg);
30689 uint64_t ret_ref = 0;
30690 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30691 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30695 static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
30696 LDKPong ret_var = Pong_clone(arg);
30697 uint64_t ret_ref = 0;
30698 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30699 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30702 int64_t __attribute__((export_name("TS_Pong_clone_ptr"))) TS_Pong_clone_ptr(uint64_t arg) {
30704 arg_conv.inner = untag_ptr(arg);
30705 arg_conv.is_owned = ptr_is_owned(arg);
30706 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30707 arg_conv.is_owned = false;
30708 int64_t ret_conv = Pong_clone_ptr(&arg_conv);
30712 uint64_t __attribute__((export_name("TS_Pong_clone"))) TS_Pong_clone(uint64_t orig) {
30714 orig_conv.inner = untag_ptr(orig);
30715 orig_conv.is_owned = ptr_is_owned(orig);
30716 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30717 orig_conv.is_owned = false;
30718 LDKPong ret_var = Pong_clone(&orig_conv);
30719 uint64_t ret_ref = 0;
30720 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30721 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30725 jboolean __attribute__((export_name("TS_Pong_eq"))) TS_Pong_eq(uint64_t a, uint64_t b) {
30727 a_conv.inner = untag_ptr(a);
30728 a_conv.is_owned = ptr_is_owned(a);
30729 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30730 a_conv.is_owned = false;
30732 b_conv.inner = untag_ptr(b);
30733 b_conv.is_owned = ptr_is_owned(b);
30734 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30735 b_conv.is_owned = false;
30736 jboolean ret_conv = Pong_eq(&a_conv, &b_conv);
30740 void __attribute__((export_name("TS_OpenChannel_free"))) TS_OpenChannel_free(uint64_t this_obj) {
30741 LDKOpenChannel this_obj_conv;
30742 this_obj_conv.inner = untag_ptr(this_obj);
30743 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30744 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30745 OpenChannel_free(this_obj_conv);
30748 int8_tArray __attribute__((export_name("TS_OpenChannel_get_chain_hash"))) TS_OpenChannel_get_chain_hash(uint64_t this_ptr) {
30749 LDKOpenChannel 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(32, __LINE__);
30755 memcpy(ret_arr->elems, *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
30759 void __attribute__((export_name("TS_OpenChannel_set_chain_hash"))) TS_OpenChannel_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
30760 LDKOpenChannel 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 LDKThirtyTwoBytes val_ref;
30766 CHECK(val->arr_len == 32);
30767 memcpy(val_ref.data, val->elems, 32); FREE(val);
30768 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
30771 int8_tArray __attribute__((export_name("TS_OpenChannel_get_temporary_channel_id"))) TS_OpenChannel_get_temporary_channel_id(uint64_t this_ptr) {
30772 LDKOpenChannel 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(32, __LINE__);
30778 memcpy(ret_arr->elems, *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
30782 void __attribute__((export_name("TS_OpenChannel_set_temporary_channel_id"))) TS_OpenChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
30783 LDKOpenChannel 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 LDKThirtyTwoBytes val_ref;
30789 CHECK(val->arr_len == 32);
30790 memcpy(val_ref.data, val->elems, 32); FREE(val);
30791 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
30794 int64_t __attribute__((export_name("TS_OpenChannel_get_funding_satoshis"))) TS_OpenChannel_get_funding_satoshis(uint64_t this_ptr) {
30795 LDKOpenChannel 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 int64_t ret_conv = OpenChannel_get_funding_satoshis(&this_ptr_conv);
30804 void __attribute__((export_name("TS_OpenChannel_set_funding_satoshis"))) TS_OpenChannel_set_funding_satoshis(uint64_t this_ptr, int64_t val) {
30805 LDKOpenChannel this_ptr_conv;
30806 this_ptr_conv.inner = untag_ptr(this_ptr);
30807 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30809 this_ptr_conv.is_owned = false;
30810 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
30813 int64_t __attribute__((export_name("TS_OpenChannel_get_push_msat"))) TS_OpenChannel_get_push_msat(uint64_t this_ptr) {
30814 LDKOpenChannel this_ptr_conv;
30815 this_ptr_conv.inner = untag_ptr(this_ptr);
30816 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30818 this_ptr_conv.is_owned = false;
30819 int64_t ret_conv = OpenChannel_get_push_msat(&this_ptr_conv);
30823 void __attribute__((export_name("TS_OpenChannel_set_push_msat"))) TS_OpenChannel_set_push_msat(uint64_t this_ptr, int64_t val) {
30824 LDKOpenChannel this_ptr_conv;
30825 this_ptr_conv.inner = untag_ptr(this_ptr);
30826 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30828 this_ptr_conv.is_owned = false;
30829 OpenChannel_set_push_msat(&this_ptr_conv, val);
30832 int64_t __attribute__((export_name("TS_OpenChannel_get_dust_limit_satoshis"))) TS_OpenChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
30833 LDKOpenChannel this_ptr_conv;
30834 this_ptr_conv.inner = untag_ptr(this_ptr);
30835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30837 this_ptr_conv.is_owned = false;
30838 int64_t ret_conv = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
30842 void __attribute__((export_name("TS_OpenChannel_set_dust_limit_satoshis"))) TS_OpenChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
30843 LDKOpenChannel this_ptr_conv;
30844 this_ptr_conv.inner = untag_ptr(this_ptr);
30845 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30846 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30847 this_ptr_conv.is_owned = false;
30848 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
30851 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) {
30852 LDKOpenChannel 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 int64_t ret_conv = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
30861 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) {
30862 LDKOpenChannel this_ptr_conv;
30863 this_ptr_conv.inner = untag_ptr(this_ptr);
30864 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30866 this_ptr_conv.is_owned = false;
30867 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
30870 int64_t __attribute__((export_name("TS_OpenChannel_get_channel_reserve_satoshis"))) TS_OpenChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
30871 LDKOpenChannel this_ptr_conv;
30872 this_ptr_conv.inner = untag_ptr(this_ptr);
30873 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30874 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30875 this_ptr_conv.is_owned = false;
30876 int64_t ret_conv = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
30880 void __attribute__((export_name("TS_OpenChannel_set_channel_reserve_satoshis"))) TS_OpenChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
30881 LDKOpenChannel this_ptr_conv;
30882 this_ptr_conv.inner = untag_ptr(this_ptr);
30883 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30885 this_ptr_conv.is_owned = false;
30886 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
30889 int64_t __attribute__((export_name("TS_OpenChannel_get_htlc_minimum_msat"))) TS_OpenChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
30890 LDKOpenChannel this_ptr_conv;
30891 this_ptr_conv.inner = untag_ptr(this_ptr);
30892 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30893 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30894 this_ptr_conv.is_owned = false;
30895 int64_t ret_conv = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
30899 void __attribute__((export_name("TS_OpenChannel_set_htlc_minimum_msat"))) TS_OpenChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
30900 LDKOpenChannel this_ptr_conv;
30901 this_ptr_conv.inner = untag_ptr(this_ptr);
30902 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30903 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30904 this_ptr_conv.is_owned = false;
30905 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
30908 int32_t __attribute__((export_name("TS_OpenChannel_get_feerate_per_kw"))) TS_OpenChannel_get_feerate_per_kw(uint64_t this_ptr) {
30909 LDKOpenChannel this_ptr_conv;
30910 this_ptr_conv.inner = untag_ptr(this_ptr);
30911 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30912 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30913 this_ptr_conv.is_owned = false;
30914 int32_t ret_conv = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
30918 void __attribute__((export_name("TS_OpenChannel_set_feerate_per_kw"))) TS_OpenChannel_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
30919 LDKOpenChannel this_ptr_conv;
30920 this_ptr_conv.inner = untag_ptr(this_ptr);
30921 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30922 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30923 this_ptr_conv.is_owned = false;
30924 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
30927 int16_t __attribute__((export_name("TS_OpenChannel_get_to_self_delay"))) TS_OpenChannel_get_to_self_delay(uint64_t this_ptr) {
30928 LDKOpenChannel this_ptr_conv;
30929 this_ptr_conv.inner = untag_ptr(this_ptr);
30930 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30932 this_ptr_conv.is_owned = false;
30933 int16_t ret_conv = OpenChannel_get_to_self_delay(&this_ptr_conv);
30937 void __attribute__((export_name("TS_OpenChannel_set_to_self_delay"))) TS_OpenChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
30938 LDKOpenChannel this_ptr_conv;
30939 this_ptr_conv.inner = untag_ptr(this_ptr);
30940 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30942 this_ptr_conv.is_owned = false;
30943 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
30946 int16_t __attribute__((export_name("TS_OpenChannel_get_max_accepted_htlcs"))) TS_OpenChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
30947 LDKOpenChannel this_ptr_conv;
30948 this_ptr_conv.inner = untag_ptr(this_ptr);
30949 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30951 this_ptr_conv.is_owned = false;
30952 int16_t ret_conv = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
30956 void __attribute__((export_name("TS_OpenChannel_set_max_accepted_htlcs"))) TS_OpenChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
30957 LDKOpenChannel this_ptr_conv;
30958 this_ptr_conv.inner = untag_ptr(this_ptr);
30959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30961 this_ptr_conv.is_owned = false;
30962 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
30965 int8_tArray __attribute__((export_name("TS_OpenChannel_get_funding_pubkey"))) TS_OpenChannel_get_funding_pubkey(uint64_t this_ptr) {
30966 LDKOpenChannel this_ptr_conv;
30967 this_ptr_conv.inner = untag_ptr(this_ptr);
30968 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30970 this_ptr_conv.is_owned = false;
30971 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30972 memcpy(ret_arr->elems, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
30976 void __attribute__((export_name("TS_OpenChannel_set_funding_pubkey"))) TS_OpenChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
30977 LDKOpenChannel this_ptr_conv;
30978 this_ptr_conv.inner = untag_ptr(this_ptr);
30979 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30980 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30981 this_ptr_conv.is_owned = false;
30982 LDKPublicKey val_ref;
30983 CHECK(val->arr_len == 33);
30984 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30985 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
30988 int8_tArray __attribute__((export_name("TS_OpenChannel_get_revocation_basepoint"))) TS_OpenChannel_get_revocation_basepoint(uint64_t this_ptr) {
30989 LDKOpenChannel this_ptr_conv;
30990 this_ptr_conv.inner = untag_ptr(this_ptr);
30991 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30992 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30993 this_ptr_conv.is_owned = false;
30994 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30995 memcpy(ret_arr->elems, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
30999 void __attribute__((export_name("TS_OpenChannel_set_revocation_basepoint"))) TS_OpenChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
31000 LDKOpenChannel 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 LDKPublicKey val_ref;
31006 CHECK(val->arr_len == 33);
31007 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31008 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
31011 int8_tArray __attribute__((export_name("TS_OpenChannel_get_payment_point"))) TS_OpenChannel_get_payment_point(uint64_t this_ptr) {
31012 LDKOpenChannel this_ptr_conv;
31013 this_ptr_conv.inner = untag_ptr(this_ptr);
31014 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31016 this_ptr_conv.is_owned = false;
31017 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31018 memcpy(ret_arr->elems, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
31022 void __attribute__((export_name("TS_OpenChannel_set_payment_point"))) TS_OpenChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
31023 LDKOpenChannel this_ptr_conv;
31024 this_ptr_conv.inner = untag_ptr(this_ptr);
31025 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31026 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31027 this_ptr_conv.is_owned = false;
31028 LDKPublicKey val_ref;
31029 CHECK(val->arr_len == 33);
31030 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31031 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
31034 int8_tArray __attribute__((export_name("TS_OpenChannel_get_delayed_payment_basepoint"))) TS_OpenChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
31035 LDKOpenChannel this_ptr_conv;
31036 this_ptr_conv.inner = untag_ptr(this_ptr);
31037 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31039 this_ptr_conv.is_owned = false;
31040 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31041 memcpy(ret_arr->elems, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
31045 void __attribute__((export_name("TS_OpenChannel_set_delayed_payment_basepoint"))) TS_OpenChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
31046 LDKOpenChannel this_ptr_conv;
31047 this_ptr_conv.inner = untag_ptr(this_ptr);
31048 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31049 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31050 this_ptr_conv.is_owned = false;
31051 LDKPublicKey val_ref;
31052 CHECK(val->arr_len == 33);
31053 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31054 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
31057 int8_tArray __attribute__((export_name("TS_OpenChannel_get_htlc_basepoint"))) TS_OpenChannel_get_htlc_basepoint(uint64_t this_ptr) {
31058 LDKOpenChannel this_ptr_conv;
31059 this_ptr_conv.inner = untag_ptr(this_ptr);
31060 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31061 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31062 this_ptr_conv.is_owned = false;
31063 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31064 memcpy(ret_arr->elems, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
31068 void __attribute__((export_name("TS_OpenChannel_set_htlc_basepoint"))) TS_OpenChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
31069 LDKOpenChannel this_ptr_conv;
31070 this_ptr_conv.inner = untag_ptr(this_ptr);
31071 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31072 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31073 this_ptr_conv.is_owned = false;
31074 LDKPublicKey val_ref;
31075 CHECK(val->arr_len == 33);
31076 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31077 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
31080 int8_tArray __attribute__((export_name("TS_OpenChannel_get_first_per_commitment_point"))) TS_OpenChannel_get_first_per_commitment_point(uint64_t this_ptr) {
31081 LDKOpenChannel this_ptr_conv;
31082 this_ptr_conv.inner = untag_ptr(this_ptr);
31083 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31085 this_ptr_conv.is_owned = false;
31086 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31087 memcpy(ret_arr->elems, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31091 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) {
31092 LDKOpenChannel this_ptr_conv;
31093 this_ptr_conv.inner = untag_ptr(this_ptr);
31094 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31096 this_ptr_conv.is_owned = false;
31097 LDKPublicKey val_ref;
31098 CHECK(val->arr_len == 33);
31099 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31100 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
31103 int8_t __attribute__((export_name("TS_OpenChannel_get_channel_flags"))) TS_OpenChannel_get_channel_flags(uint64_t this_ptr) {
31104 LDKOpenChannel this_ptr_conv;
31105 this_ptr_conv.inner = untag_ptr(this_ptr);
31106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31108 this_ptr_conv.is_owned = false;
31109 int8_t ret_conv = OpenChannel_get_channel_flags(&this_ptr_conv);
31113 void __attribute__((export_name("TS_OpenChannel_set_channel_flags"))) TS_OpenChannel_set_channel_flags(uint64_t this_ptr, int8_t val) {
31114 LDKOpenChannel this_ptr_conv;
31115 this_ptr_conv.inner = untag_ptr(this_ptr);
31116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31118 this_ptr_conv.is_owned = false;
31119 OpenChannel_set_channel_flags(&this_ptr_conv, val);
31122 uint64_t __attribute__((export_name("TS_OpenChannel_get_channel_type"))) TS_OpenChannel_get_channel_type(uint64_t this_ptr) {
31123 LDKOpenChannel this_ptr_conv;
31124 this_ptr_conv.inner = untag_ptr(this_ptr);
31125 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31127 this_ptr_conv.is_owned = false;
31128 LDKChannelTypeFeatures ret_var = OpenChannel_get_channel_type(&this_ptr_conv);
31129 uint64_t ret_ref = 0;
31130 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31131 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31135 void __attribute__((export_name("TS_OpenChannel_set_channel_type"))) TS_OpenChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
31136 LDKOpenChannel 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 LDKChannelTypeFeatures val_conv;
31142 val_conv.inner = untag_ptr(val);
31143 val_conv.is_owned = ptr_is_owned(val);
31144 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31145 val_conv = ChannelTypeFeatures_clone(&val_conv);
31146 OpenChannel_set_channel_type(&this_ptr_conv, val_conv);
31149 static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
31150 LDKOpenChannel ret_var = OpenChannel_clone(arg);
31151 uint64_t ret_ref = 0;
31152 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31153 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31156 int64_t __attribute__((export_name("TS_OpenChannel_clone_ptr"))) TS_OpenChannel_clone_ptr(uint64_t arg) {
31157 LDKOpenChannel arg_conv;
31158 arg_conv.inner = untag_ptr(arg);
31159 arg_conv.is_owned = ptr_is_owned(arg);
31160 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31161 arg_conv.is_owned = false;
31162 int64_t ret_conv = OpenChannel_clone_ptr(&arg_conv);
31166 uint64_t __attribute__((export_name("TS_OpenChannel_clone"))) TS_OpenChannel_clone(uint64_t orig) {
31167 LDKOpenChannel orig_conv;
31168 orig_conv.inner = untag_ptr(orig);
31169 orig_conv.is_owned = ptr_is_owned(orig);
31170 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31171 orig_conv.is_owned = false;
31172 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
31173 uint64_t ret_ref = 0;
31174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31175 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31179 jboolean __attribute__((export_name("TS_OpenChannel_eq"))) TS_OpenChannel_eq(uint64_t a, uint64_t b) {
31180 LDKOpenChannel a_conv;
31181 a_conv.inner = untag_ptr(a);
31182 a_conv.is_owned = ptr_is_owned(a);
31183 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31184 a_conv.is_owned = false;
31185 LDKOpenChannel b_conv;
31186 b_conv.inner = untag_ptr(b);
31187 b_conv.is_owned = ptr_is_owned(b);
31188 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31189 b_conv.is_owned = false;
31190 jboolean ret_conv = OpenChannel_eq(&a_conv, &b_conv);
31194 void __attribute__((export_name("TS_AcceptChannel_free"))) TS_AcceptChannel_free(uint64_t this_obj) {
31195 LDKAcceptChannel this_obj_conv;
31196 this_obj_conv.inner = untag_ptr(this_obj);
31197 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31199 AcceptChannel_free(this_obj_conv);
31202 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_temporary_channel_id"))) TS_AcceptChannel_get_temporary_channel_id(uint64_t this_ptr) {
31203 LDKAcceptChannel this_ptr_conv;
31204 this_ptr_conv.inner = untag_ptr(this_ptr);
31205 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31207 this_ptr_conv.is_owned = false;
31208 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31209 memcpy(ret_arr->elems, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
31213 void __attribute__((export_name("TS_AcceptChannel_set_temporary_channel_id"))) TS_AcceptChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
31214 LDKAcceptChannel this_ptr_conv;
31215 this_ptr_conv.inner = untag_ptr(this_ptr);
31216 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31218 this_ptr_conv.is_owned = false;
31219 LDKThirtyTwoBytes val_ref;
31220 CHECK(val->arr_len == 32);
31221 memcpy(val_ref.data, val->elems, 32); FREE(val);
31222 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
31225 int64_t __attribute__((export_name("TS_AcceptChannel_get_dust_limit_satoshis"))) TS_AcceptChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
31226 LDKAcceptChannel 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 int64_t ret_conv = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
31235 void __attribute__((export_name("TS_AcceptChannel_set_dust_limit_satoshis"))) TS_AcceptChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
31236 LDKAcceptChannel this_ptr_conv;
31237 this_ptr_conv.inner = untag_ptr(this_ptr);
31238 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31239 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31240 this_ptr_conv.is_owned = false;
31241 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
31244 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) {
31245 LDKAcceptChannel this_ptr_conv;
31246 this_ptr_conv.inner = untag_ptr(this_ptr);
31247 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31249 this_ptr_conv.is_owned = false;
31250 int64_t ret_conv = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
31254 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) {
31255 LDKAcceptChannel this_ptr_conv;
31256 this_ptr_conv.inner = untag_ptr(this_ptr);
31257 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31259 this_ptr_conv.is_owned = false;
31260 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
31263 int64_t __attribute__((export_name("TS_AcceptChannel_get_channel_reserve_satoshis"))) TS_AcceptChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
31264 LDKAcceptChannel this_ptr_conv;
31265 this_ptr_conv.inner = untag_ptr(this_ptr);
31266 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31268 this_ptr_conv.is_owned = false;
31269 int64_t ret_conv = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
31273 void __attribute__((export_name("TS_AcceptChannel_set_channel_reserve_satoshis"))) TS_AcceptChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
31274 LDKAcceptChannel this_ptr_conv;
31275 this_ptr_conv.inner = untag_ptr(this_ptr);
31276 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31278 this_ptr_conv.is_owned = false;
31279 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
31282 int64_t __attribute__((export_name("TS_AcceptChannel_get_htlc_minimum_msat"))) TS_AcceptChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
31283 LDKAcceptChannel this_ptr_conv;
31284 this_ptr_conv.inner = untag_ptr(this_ptr);
31285 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31287 this_ptr_conv.is_owned = false;
31288 int64_t ret_conv = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
31292 void __attribute__((export_name("TS_AcceptChannel_set_htlc_minimum_msat"))) TS_AcceptChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
31293 LDKAcceptChannel this_ptr_conv;
31294 this_ptr_conv.inner = untag_ptr(this_ptr);
31295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31297 this_ptr_conv.is_owned = false;
31298 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
31301 int32_t __attribute__((export_name("TS_AcceptChannel_get_minimum_depth"))) TS_AcceptChannel_get_minimum_depth(uint64_t this_ptr) {
31302 LDKAcceptChannel this_ptr_conv;
31303 this_ptr_conv.inner = untag_ptr(this_ptr);
31304 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31306 this_ptr_conv.is_owned = false;
31307 int32_t ret_conv = AcceptChannel_get_minimum_depth(&this_ptr_conv);
31311 void __attribute__((export_name("TS_AcceptChannel_set_minimum_depth"))) TS_AcceptChannel_set_minimum_depth(uint64_t this_ptr, int32_t val) {
31312 LDKAcceptChannel this_ptr_conv;
31313 this_ptr_conv.inner = untag_ptr(this_ptr);
31314 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31316 this_ptr_conv.is_owned = false;
31317 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
31320 int16_t __attribute__((export_name("TS_AcceptChannel_get_to_self_delay"))) TS_AcceptChannel_get_to_self_delay(uint64_t this_ptr) {
31321 LDKAcceptChannel this_ptr_conv;
31322 this_ptr_conv.inner = untag_ptr(this_ptr);
31323 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31325 this_ptr_conv.is_owned = false;
31326 int16_t ret_conv = AcceptChannel_get_to_self_delay(&this_ptr_conv);
31330 void __attribute__((export_name("TS_AcceptChannel_set_to_self_delay"))) TS_AcceptChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
31331 LDKAcceptChannel this_ptr_conv;
31332 this_ptr_conv.inner = untag_ptr(this_ptr);
31333 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31335 this_ptr_conv.is_owned = false;
31336 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
31339 int16_t __attribute__((export_name("TS_AcceptChannel_get_max_accepted_htlcs"))) TS_AcceptChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
31340 LDKAcceptChannel this_ptr_conv;
31341 this_ptr_conv.inner = untag_ptr(this_ptr);
31342 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31344 this_ptr_conv.is_owned = false;
31345 int16_t ret_conv = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
31349 void __attribute__((export_name("TS_AcceptChannel_set_max_accepted_htlcs"))) TS_AcceptChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
31350 LDKAcceptChannel this_ptr_conv;
31351 this_ptr_conv.inner = untag_ptr(this_ptr);
31352 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31354 this_ptr_conv.is_owned = false;
31355 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
31358 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_funding_pubkey"))) TS_AcceptChannel_get_funding_pubkey(uint64_t this_ptr) {
31359 LDKAcceptChannel this_ptr_conv;
31360 this_ptr_conv.inner = untag_ptr(this_ptr);
31361 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31363 this_ptr_conv.is_owned = false;
31364 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31365 memcpy(ret_arr->elems, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
31369 void __attribute__((export_name("TS_AcceptChannel_set_funding_pubkey"))) TS_AcceptChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
31370 LDKAcceptChannel this_ptr_conv;
31371 this_ptr_conv.inner = untag_ptr(this_ptr);
31372 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31374 this_ptr_conv.is_owned = false;
31375 LDKPublicKey val_ref;
31376 CHECK(val->arr_len == 33);
31377 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31378 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
31381 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_revocation_basepoint"))) TS_AcceptChannel_get_revocation_basepoint(uint64_t this_ptr) {
31382 LDKAcceptChannel this_ptr_conv;
31383 this_ptr_conv.inner = untag_ptr(this_ptr);
31384 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31386 this_ptr_conv.is_owned = false;
31387 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31388 memcpy(ret_arr->elems, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
31392 void __attribute__((export_name("TS_AcceptChannel_set_revocation_basepoint"))) TS_AcceptChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
31393 LDKAcceptChannel this_ptr_conv;
31394 this_ptr_conv.inner = untag_ptr(this_ptr);
31395 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31396 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31397 this_ptr_conv.is_owned = false;
31398 LDKPublicKey val_ref;
31399 CHECK(val->arr_len == 33);
31400 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31401 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
31404 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_payment_point"))) TS_AcceptChannel_get_payment_point(uint64_t this_ptr) {
31405 LDKAcceptChannel this_ptr_conv;
31406 this_ptr_conv.inner = untag_ptr(this_ptr);
31407 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31408 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31409 this_ptr_conv.is_owned = false;
31410 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31411 memcpy(ret_arr->elems, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
31415 void __attribute__((export_name("TS_AcceptChannel_set_payment_point"))) TS_AcceptChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
31416 LDKAcceptChannel this_ptr_conv;
31417 this_ptr_conv.inner = untag_ptr(this_ptr);
31418 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31419 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31420 this_ptr_conv.is_owned = false;
31421 LDKPublicKey val_ref;
31422 CHECK(val->arr_len == 33);
31423 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31424 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
31427 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_delayed_payment_basepoint"))) TS_AcceptChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
31428 LDKAcceptChannel this_ptr_conv;
31429 this_ptr_conv.inner = untag_ptr(this_ptr);
31430 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31431 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31432 this_ptr_conv.is_owned = false;
31433 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31434 memcpy(ret_arr->elems, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
31438 void __attribute__((export_name("TS_AcceptChannel_set_delayed_payment_basepoint"))) TS_AcceptChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
31439 LDKAcceptChannel this_ptr_conv;
31440 this_ptr_conv.inner = untag_ptr(this_ptr);
31441 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31442 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31443 this_ptr_conv.is_owned = false;
31444 LDKPublicKey val_ref;
31445 CHECK(val->arr_len == 33);
31446 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31447 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
31450 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_htlc_basepoint"))) TS_AcceptChannel_get_htlc_basepoint(uint64_t this_ptr) {
31451 LDKAcceptChannel this_ptr_conv;
31452 this_ptr_conv.inner = untag_ptr(this_ptr);
31453 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31454 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31455 this_ptr_conv.is_owned = false;
31456 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31457 memcpy(ret_arr->elems, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
31461 void __attribute__((export_name("TS_AcceptChannel_set_htlc_basepoint"))) TS_AcceptChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
31462 LDKAcceptChannel this_ptr_conv;
31463 this_ptr_conv.inner = untag_ptr(this_ptr);
31464 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31466 this_ptr_conv.is_owned = false;
31467 LDKPublicKey val_ref;
31468 CHECK(val->arr_len == 33);
31469 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31470 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
31473 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_first_per_commitment_point"))) TS_AcceptChannel_get_first_per_commitment_point(uint64_t this_ptr) {
31474 LDKAcceptChannel this_ptr_conv;
31475 this_ptr_conv.inner = untag_ptr(this_ptr);
31476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31478 this_ptr_conv.is_owned = false;
31479 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31480 memcpy(ret_arr->elems, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31484 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) {
31485 LDKAcceptChannel this_ptr_conv;
31486 this_ptr_conv.inner = untag_ptr(this_ptr);
31487 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31488 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31489 this_ptr_conv.is_owned = false;
31490 LDKPublicKey val_ref;
31491 CHECK(val->arr_len == 33);
31492 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31493 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
31496 uint64_t __attribute__((export_name("TS_AcceptChannel_get_channel_type"))) TS_AcceptChannel_get_channel_type(uint64_t this_ptr) {
31497 LDKAcceptChannel this_ptr_conv;
31498 this_ptr_conv.inner = untag_ptr(this_ptr);
31499 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31501 this_ptr_conv.is_owned = false;
31502 LDKChannelTypeFeatures ret_var = AcceptChannel_get_channel_type(&this_ptr_conv);
31503 uint64_t ret_ref = 0;
31504 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31505 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31509 void __attribute__((export_name("TS_AcceptChannel_set_channel_type"))) TS_AcceptChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
31510 LDKAcceptChannel this_ptr_conv;
31511 this_ptr_conv.inner = untag_ptr(this_ptr);
31512 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31514 this_ptr_conv.is_owned = false;
31515 LDKChannelTypeFeatures val_conv;
31516 val_conv.inner = untag_ptr(val);
31517 val_conv.is_owned = ptr_is_owned(val);
31518 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31519 val_conv = ChannelTypeFeatures_clone(&val_conv);
31520 AcceptChannel_set_channel_type(&this_ptr_conv, val_conv);
31523 static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
31524 LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
31525 uint64_t ret_ref = 0;
31526 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31527 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31530 int64_t __attribute__((export_name("TS_AcceptChannel_clone_ptr"))) TS_AcceptChannel_clone_ptr(uint64_t arg) {
31531 LDKAcceptChannel arg_conv;
31532 arg_conv.inner = untag_ptr(arg);
31533 arg_conv.is_owned = ptr_is_owned(arg);
31534 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31535 arg_conv.is_owned = false;
31536 int64_t ret_conv = AcceptChannel_clone_ptr(&arg_conv);
31540 uint64_t __attribute__((export_name("TS_AcceptChannel_clone"))) TS_AcceptChannel_clone(uint64_t orig) {
31541 LDKAcceptChannel orig_conv;
31542 orig_conv.inner = untag_ptr(orig);
31543 orig_conv.is_owned = ptr_is_owned(orig);
31544 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31545 orig_conv.is_owned = false;
31546 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
31547 uint64_t ret_ref = 0;
31548 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31549 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31553 jboolean __attribute__((export_name("TS_AcceptChannel_eq"))) TS_AcceptChannel_eq(uint64_t a, uint64_t b) {
31554 LDKAcceptChannel a_conv;
31555 a_conv.inner = untag_ptr(a);
31556 a_conv.is_owned = ptr_is_owned(a);
31557 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31558 a_conv.is_owned = false;
31559 LDKAcceptChannel b_conv;
31560 b_conv.inner = untag_ptr(b);
31561 b_conv.is_owned = ptr_is_owned(b);
31562 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31563 b_conv.is_owned = false;
31564 jboolean ret_conv = AcceptChannel_eq(&a_conv, &b_conv);
31568 void __attribute__((export_name("TS_FundingCreated_free"))) TS_FundingCreated_free(uint64_t this_obj) {
31569 LDKFundingCreated this_obj_conv;
31570 this_obj_conv.inner = untag_ptr(this_obj);
31571 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31573 FundingCreated_free(this_obj_conv);
31576 int8_tArray __attribute__((export_name("TS_FundingCreated_get_temporary_channel_id"))) TS_FundingCreated_get_temporary_channel_id(uint64_t this_ptr) {
31577 LDKFundingCreated this_ptr_conv;
31578 this_ptr_conv.inner = untag_ptr(this_ptr);
31579 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31580 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31581 this_ptr_conv.is_owned = false;
31582 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31583 memcpy(ret_arr->elems, *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
31587 void __attribute__((export_name("TS_FundingCreated_set_temporary_channel_id"))) TS_FundingCreated_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
31588 LDKFundingCreated this_ptr_conv;
31589 this_ptr_conv.inner = untag_ptr(this_ptr);
31590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31592 this_ptr_conv.is_owned = false;
31593 LDKThirtyTwoBytes val_ref;
31594 CHECK(val->arr_len == 32);
31595 memcpy(val_ref.data, val->elems, 32); FREE(val);
31596 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
31599 int8_tArray __attribute__((export_name("TS_FundingCreated_get_funding_txid"))) TS_FundingCreated_get_funding_txid(uint64_t this_ptr) {
31600 LDKFundingCreated this_ptr_conv;
31601 this_ptr_conv.inner = untag_ptr(this_ptr);
31602 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31604 this_ptr_conv.is_owned = false;
31605 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31606 memcpy(ret_arr->elems, *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
31610 void __attribute__((export_name("TS_FundingCreated_set_funding_txid"))) TS_FundingCreated_set_funding_txid(uint64_t this_ptr, int8_tArray val) {
31611 LDKFundingCreated this_ptr_conv;
31612 this_ptr_conv.inner = untag_ptr(this_ptr);
31613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31615 this_ptr_conv.is_owned = false;
31616 LDKThirtyTwoBytes val_ref;
31617 CHECK(val->arr_len == 32);
31618 memcpy(val_ref.data, val->elems, 32); FREE(val);
31619 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
31622 int16_t __attribute__((export_name("TS_FundingCreated_get_funding_output_index"))) TS_FundingCreated_get_funding_output_index(uint64_t this_ptr) {
31623 LDKFundingCreated this_ptr_conv;
31624 this_ptr_conv.inner = untag_ptr(this_ptr);
31625 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31626 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31627 this_ptr_conv.is_owned = false;
31628 int16_t ret_conv = FundingCreated_get_funding_output_index(&this_ptr_conv);
31632 void __attribute__((export_name("TS_FundingCreated_set_funding_output_index"))) TS_FundingCreated_set_funding_output_index(uint64_t this_ptr, int16_t val) {
31633 LDKFundingCreated this_ptr_conv;
31634 this_ptr_conv.inner = untag_ptr(this_ptr);
31635 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31636 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31637 this_ptr_conv.is_owned = false;
31638 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
31641 int8_tArray __attribute__((export_name("TS_FundingCreated_get_signature"))) TS_FundingCreated_get_signature(uint64_t this_ptr) {
31642 LDKFundingCreated this_ptr_conv;
31643 this_ptr_conv.inner = untag_ptr(this_ptr);
31644 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31645 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31646 this_ptr_conv.is_owned = false;
31647 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31648 memcpy(ret_arr->elems, FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
31652 void __attribute__((export_name("TS_FundingCreated_set_signature"))) TS_FundingCreated_set_signature(uint64_t this_ptr, int8_tArray val) {
31653 LDKFundingCreated this_ptr_conv;
31654 this_ptr_conv.inner = untag_ptr(this_ptr);
31655 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31656 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31657 this_ptr_conv.is_owned = false;
31658 LDKSignature val_ref;
31659 CHECK(val->arr_len == 64);
31660 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31661 FundingCreated_set_signature(&this_ptr_conv, val_ref);
31664 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) {
31665 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
31666 CHECK(temporary_channel_id_arg->arr_len == 32);
31667 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
31668 LDKThirtyTwoBytes funding_txid_arg_ref;
31669 CHECK(funding_txid_arg->arr_len == 32);
31670 memcpy(funding_txid_arg_ref.data, funding_txid_arg->elems, 32); FREE(funding_txid_arg);
31671 LDKSignature signature_arg_ref;
31672 CHECK(signature_arg->arr_len == 64);
31673 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31674 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
31675 uint64_t ret_ref = 0;
31676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31677 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31681 static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
31682 LDKFundingCreated ret_var = FundingCreated_clone(arg);
31683 uint64_t ret_ref = 0;
31684 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31685 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31688 int64_t __attribute__((export_name("TS_FundingCreated_clone_ptr"))) TS_FundingCreated_clone_ptr(uint64_t arg) {
31689 LDKFundingCreated arg_conv;
31690 arg_conv.inner = untag_ptr(arg);
31691 arg_conv.is_owned = ptr_is_owned(arg);
31692 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31693 arg_conv.is_owned = false;
31694 int64_t ret_conv = FundingCreated_clone_ptr(&arg_conv);
31698 uint64_t __attribute__((export_name("TS_FundingCreated_clone"))) TS_FundingCreated_clone(uint64_t orig) {
31699 LDKFundingCreated orig_conv;
31700 orig_conv.inner = untag_ptr(orig);
31701 orig_conv.is_owned = ptr_is_owned(orig);
31702 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31703 orig_conv.is_owned = false;
31704 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
31705 uint64_t ret_ref = 0;
31706 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31707 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31711 jboolean __attribute__((export_name("TS_FundingCreated_eq"))) TS_FundingCreated_eq(uint64_t a, uint64_t b) {
31712 LDKFundingCreated a_conv;
31713 a_conv.inner = untag_ptr(a);
31714 a_conv.is_owned = ptr_is_owned(a);
31715 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31716 a_conv.is_owned = false;
31717 LDKFundingCreated b_conv;
31718 b_conv.inner = untag_ptr(b);
31719 b_conv.is_owned = ptr_is_owned(b);
31720 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31721 b_conv.is_owned = false;
31722 jboolean ret_conv = FundingCreated_eq(&a_conv, &b_conv);
31726 void __attribute__((export_name("TS_FundingSigned_free"))) TS_FundingSigned_free(uint64_t this_obj) {
31727 LDKFundingSigned this_obj_conv;
31728 this_obj_conv.inner = untag_ptr(this_obj);
31729 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31731 FundingSigned_free(this_obj_conv);
31734 int8_tArray __attribute__((export_name("TS_FundingSigned_get_channel_id"))) TS_FundingSigned_get_channel_id(uint64_t this_ptr) {
31735 LDKFundingSigned this_ptr_conv;
31736 this_ptr_conv.inner = untag_ptr(this_ptr);
31737 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31739 this_ptr_conv.is_owned = false;
31740 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31741 memcpy(ret_arr->elems, *FundingSigned_get_channel_id(&this_ptr_conv), 32);
31745 void __attribute__((export_name("TS_FundingSigned_set_channel_id"))) TS_FundingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31746 LDKFundingSigned this_ptr_conv;
31747 this_ptr_conv.inner = untag_ptr(this_ptr);
31748 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31749 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31750 this_ptr_conv.is_owned = false;
31751 LDKThirtyTwoBytes val_ref;
31752 CHECK(val->arr_len == 32);
31753 memcpy(val_ref.data, val->elems, 32); FREE(val);
31754 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
31757 int8_tArray __attribute__((export_name("TS_FundingSigned_get_signature"))) TS_FundingSigned_get_signature(uint64_t this_ptr) {
31758 LDKFundingSigned this_ptr_conv;
31759 this_ptr_conv.inner = untag_ptr(this_ptr);
31760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31762 this_ptr_conv.is_owned = false;
31763 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31764 memcpy(ret_arr->elems, FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
31768 void __attribute__((export_name("TS_FundingSigned_set_signature"))) TS_FundingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
31769 LDKFundingSigned 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 LDKSignature val_ref;
31775 CHECK(val->arr_len == 64);
31776 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31777 FundingSigned_set_signature(&this_ptr_conv, val_ref);
31780 uint64_t __attribute__((export_name("TS_FundingSigned_new"))) TS_FundingSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg) {
31781 LDKThirtyTwoBytes channel_id_arg_ref;
31782 CHECK(channel_id_arg->arr_len == 32);
31783 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31784 LDKSignature signature_arg_ref;
31785 CHECK(signature_arg->arr_len == 64);
31786 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31787 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
31788 uint64_t ret_ref = 0;
31789 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31790 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31794 static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
31795 LDKFundingSigned ret_var = FundingSigned_clone(arg);
31796 uint64_t ret_ref = 0;
31797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31798 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31801 int64_t __attribute__((export_name("TS_FundingSigned_clone_ptr"))) TS_FundingSigned_clone_ptr(uint64_t arg) {
31802 LDKFundingSigned arg_conv;
31803 arg_conv.inner = untag_ptr(arg);
31804 arg_conv.is_owned = ptr_is_owned(arg);
31805 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31806 arg_conv.is_owned = false;
31807 int64_t ret_conv = FundingSigned_clone_ptr(&arg_conv);
31811 uint64_t __attribute__((export_name("TS_FundingSigned_clone"))) TS_FundingSigned_clone(uint64_t orig) {
31812 LDKFundingSigned orig_conv;
31813 orig_conv.inner = untag_ptr(orig);
31814 orig_conv.is_owned = ptr_is_owned(orig);
31815 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31816 orig_conv.is_owned = false;
31817 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
31818 uint64_t ret_ref = 0;
31819 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31820 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31824 jboolean __attribute__((export_name("TS_FundingSigned_eq"))) TS_FundingSigned_eq(uint64_t a, uint64_t b) {
31825 LDKFundingSigned a_conv;
31826 a_conv.inner = untag_ptr(a);
31827 a_conv.is_owned = ptr_is_owned(a);
31828 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31829 a_conv.is_owned = false;
31830 LDKFundingSigned b_conv;
31831 b_conv.inner = untag_ptr(b);
31832 b_conv.is_owned = ptr_is_owned(b);
31833 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31834 b_conv.is_owned = false;
31835 jboolean ret_conv = FundingSigned_eq(&a_conv, &b_conv);
31839 void __attribute__((export_name("TS_ChannelReady_free"))) TS_ChannelReady_free(uint64_t this_obj) {
31840 LDKChannelReady this_obj_conv;
31841 this_obj_conv.inner = untag_ptr(this_obj);
31842 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31844 ChannelReady_free(this_obj_conv);
31847 int8_tArray __attribute__((export_name("TS_ChannelReady_get_channel_id"))) TS_ChannelReady_get_channel_id(uint64_t this_ptr) {
31848 LDKChannelReady this_ptr_conv;
31849 this_ptr_conv.inner = untag_ptr(this_ptr);
31850 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31852 this_ptr_conv.is_owned = false;
31853 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31854 memcpy(ret_arr->elems, *ChannelReady_get_channel_id(&this_ptr_conv), 32);
31858 void __attribute__((export_name("TS_ChannelReady_set_channel_id"))) TS_ChannelReady_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31859 LDKChannelReady this_ptr_conv;
31860 this_ptr_conv.inner = untag_ptr(this_ptr);
31861 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31862 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31863 this_ptr_conv.is_owned = false;
31864 LDKThirtyTwoBytes val_ref;
31865 CHECK(val->arr_len == 32);
31866 memcpy(val_ref.data, val->elems, 32); FREE(val);
31867 ChannelReady_set_channel_id(&this_ptr_conv, val_ref);
31870 int8_tArray __attribute__((export_name("TS_ChannelReady_get_next_per_commitment_point"))) TS_ChannelReady_get_next_per_commitment_point(uint64_t this_ptr) {
31871 LDKChannelReady this_ptr_conv;
31872 this_ptr_conv.inner = untag_ptr(this_ptr);
31873 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31874 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31875 this_ptr_conv.is_owned = false;
31876 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31877 memcpy(ret_arr->elems, ChannelReady_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31881 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) {
31882 LDKChannelReady this_ptr_conv;
31883 this_ptr_conv.inner = untag_ptr(this_ptr);
31884 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31886 this_ptr_conv.is_owned = false;
31887 LDKPublicKey val_ref;
31888 CHECK(val->arr_len == 33);
31889 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31890 ChannelReady_set_next_per_commitment_point(&this_ptr_conv, val_ref);
31893 uint64_t __attribute__((export_name("TS_ChannelReady_get_short_channel_id_alias"))) TS_ChannelReady_get_short_channel_id_alias(uint64_t this_ptr) {
31894 LDKChannelReady this_ptr_conv;
31895 this_ptr_conv.inner = untag_ptr(this_ptr);
31896 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31898 this_ptr_conv.is_owned = false;
31899 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
31900 *ret_copy = ChannelReady_get_short_channel_id_alias(&this_ptr_conv);
31901 uint64_t ret_ref = tag_ptr(ret_copy, true);
31905 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) {
31906 LDKChannelReady this_ptr_conv;
31907 this_ptr_conv.inner = untag_ptr(this_ptr);
31908 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31910 this_ptr_conv.is_owned = false;
31911 void* val_ptr = untag_ptr(val);
31912 CHECK_ACCESS(val_ptr);
31913 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
31914 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
31915 ChannelReady_set_short_channel_id_alias(&this_ptr_conv, val_conv);
31918 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) {
31919 LDKThirtyTwoBytes channel_id_arg_ref;
31920 CHECK(channel_id_arg->arr_len == 32);
31921 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31922 LDKPublicKey next_per_commitment_point_arg_ref;
31923 CHECK(next_per_commitment_point_arg->arr_len == 33);
31924 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
31925 void* short_channel_id_alias_arg_ptr = untag_ptr(short_channel_id_alias_arg);
31926 CHECK_ACCESS(short_channel_id_alias_arg_ptr);
31927 LDKCOption_u64Z short_channel_id_alias_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_alias_arg_ptr);
31928 short_channel_id_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_alias_arg));
31929 LDKChannelReady ret_var = ChannelReady_new(channel_id_arg_ref, next_per_commitment_point_arg_ref, short_channel_id_alias_arg_conv);
31930 uint64_t ret_ref = 0;
31931 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31932 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31936 static inline uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg) {
31937 LDKChannelReady ret_var = ChannelReady_clone(arg);
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);
31943 int64_t __attribute__((export_name("TS_ChannelReady_clone_ptr"))) TS_ChannelReady_clone_ptr(uint64_t arg) {
31944 LDKChannelReady arg_conv;
31945 arg_conv.inner = untag_ptr(arg);
31946 arg_conv.is_owned = ptr_is_owned(arg);
31947 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31948 arg_conv.is_owned = false;
31949 int64_t ret_conv = ChannelReady_clone_ptr(&arg_conv);
31953 uint64_t __attribute__((export_name("TS_ChannelReady_clone"))) TS_ChannelReady_clone(uint64_t orig) {
31954 LDKChannelReady orig_conv;
31955 orig_conv.inner = untag_ptr(orig);
31956 orig_conv.is_owned = ptr_is_owned(orig);
31957 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31958 orig_conv.is_owned = false;
31959 LDKChannelReady ret_var = ChannelReady_clone(&orig_conv);
31960 uint64_t ret_ref = 0;
31961 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31962 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31966 jboolean __attribute__((export_name("TS_ChannelReady_eq"))) TS_ChannelReady_eq(uint64_t a, uint64_t b) {
31967 LDKChannelReady a_conv;
31968 a_conv.inner = untag_ptr(a);
31969 a_conv.is_owned = ptr_is_owned(a);
31970 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31971 a_conv.is_owned = false;
31972 LDKChannelReady b_conv;
31973 b_conv.inner = untag_ptr(b);
31974 b_conv.is_owned = ptr_is_owned(b);
31975 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31976 b_conv.is_owned = false;
31977 jboolean ret_conv = ChannelReady_eq(&a_conv, &b_conv);
31981 void __attribute__((export_name("TS_Shutdown_free"))) TS_Shutdown_free(uint64_t this_obj) {
31982 LDKShutdown this_obj_conv;
31983 this_obj_conv.inner = untag_ptr(this_obj);
31984 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31986 Shutdown_free(this_obj_conv);
31989 int8_tArray __attribute__((export_name("TS_Shutdown_get_channel_id"))) TS_Shutdown_get_channel_id(uint64_t this_ptr) {
31990 LDKShutdown this_ptr_conv;
31991 this_ptr_conv.inner = untag_ptr(this_ptr);
31992 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31994 this_ptr_conv.is_owned = false;
31995 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31996 memcpy(ret_arr->elems, *Shutdown_get_channel_id(&this_ptr_conv), 32);
32000 void __attribute__((export_name("TS_Shutdown_set_channel_id"))) TS_Shutdown_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32001 LDKShutdown 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 LDKThirtyTwoBytes val_ref;
32007 CHECK(val->arr_len == 32);
32008 memcpy(val_ref.data, val->elems, 32); FREE(val);
32009 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
32012 int8_tArray __attribute__((export_name("TS_Shutdown_get_scriptpubkey"))) TS_Shutdown_get_scriptpubkey(uint64_t this_ptr) {
32013 LDKShutdown this_ptr_conv;
32014 this_ptr_conv.inner = untag_ptr(this_ptr);
32015 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32016 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32017 this_ptr_conv.is_owned = false;
32018 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
32019 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
32020 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
32024 void __attribute__((export_name("TS_Shutdown_set_scriptpubkey"))) TS_Shutdown_set_scriptpubkey(uint64_t this_ptr, int8_tArray val) {
32025 LDKShutdown this_ptr_conv;
32026 this_ptr_conv.inner = untag_ptr(this_ptr);
32027 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32028 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32029 this_ptr_conv.is_owned = false;
32030 LDKCVec_u8Z val_ref;
32031 val_ref.datalen = val->arr_len;
32032 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
32033 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
32034 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
32037 uint64_t __attribute__((export_name("TS_Shutdown_new"))) TS_Shutdown_new(int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
32038 LDKThirtyTwoBytes channel_id_arg_ref;
32039 CHECK(channel_id_arg->arr_len == 32);
32040 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32041 LDKCVec_u8Z scriptpubkey_arg_ref;
32042 scriptpubkey_arg_ref.datalen = scriptpubkey_arg->arr_len;
32043 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
32044 memcpy(scriptpubkey_arg_ref.data, scriptpubkey_arg->elems, scriptpubkey_arg_ref.datalen); FREE(scriptpubkey_arg);
32045 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
32046 uint64_t ret_ref = 0;
32047 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32048 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32052 static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
32053 LDKShutdown ret_var = Shutdown_clone(arg);
32054 uint64_t ret_ref = 0;
32055 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32056 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32059 int64_t __attribute__((export_name("TS_Shutdown_clone_ptr"))) TS_Shutdown_clone_ptr(uint64_t arg) {
32060 LDKShutdown arg_conv;
32061 arg_conv.inner = untag_ptr(arg);
32062 arg_conv.is_owned = ptr_is_owned(arg);
32063 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32064 arg_conv.is_owned = false;
32065 int64_t ret_conv = Shutdown_clone_ptr(&arg_conv);
32069 uint64_t __attribute__((export_name("TS_Shutdown_clone"))) TS_Shutdown_clone(uint64_t orig) {
32070 LDKShutdown orig_conv;
32071 orig_conv.inner = untag_ptr(orig);
32072 orig_conv.is_owned = ptr_is_owned(orig);
32073 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32074 orig_conv.is_owned = false;
32075 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
32076 uint64_t ret_ref = 0;
32077 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32078 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32082 jboolean __attribute__((export_name("TS_Shutdown_eq"))) TS_Shutdown_eq(uint64_t a, uint64_t b) {
32083 LDKShutdown a_conv;
32084 a_conv.inner = untag_ptr(a);
32085 a_conv.is_owned = ptr_is_owned(a);
32086 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32087 a_conv.is_owned = false;
32088 LDKShutdown b_conv;
32089 b_conv.inner = untag_ptr(b);
32090 b_conv.is_owned = ptr_is_owned(b);
32091 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32092 b_conv.is_owned = false;
32093 jboolean ret_conv = Shutdown_eq(&a_conv, &b_conv);
32097 void __attribute__((export_name("TS_ClosingSignedFeeRange_free"))) TS_ClosingSignedFeeRange_free(uint64_t this_obj) {
32098 LDKClosingSignedFeeRange this_obj_conv;
32099 this_obj_conv.inner = untag_ptr(this_obj);
32100 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32101 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32102 ClosingSignedFeeRange_free(this_obj_conv);
32105 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_min_fee_satoshis"))) TS_ClosingSignedFeeRange_get_min_fee_satoshis(uint64_t this_ptr) {
32106 LDKClosingSignedFeeRange this_ptr_conv;
32107 this_ptr_conv.inner = untag_ptr(this_ptr);
32108 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32110 this_ptr_conv.is_owned = false;
32111 int64_t ret_conv = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
32115 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_min_fee_satoshis"))) TS_ClosingSignedFeeRange_set_min_fee_satoshis(uint64_t this_ptr, int64_t val) {
32116 LDKClosingSignedFeeRange this_ptr_conv;
32117 this_ptr_conv.inner = untag_ptr(this_ptr);
32118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32120 this_ptr_conv.is_owned = false;
32121 ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
32124 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_max_fee_satoshis"))) TS_ClosingSignedFeeRange_get_max_fee_satoshis(uint64_t this_ptr) {
32125 LDKClosingSignedFeeRange this_ptr_conv;
32126 this_ptr_conv.inner = untag_ptr(this_ptr);
32127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32129 this_ptr_conv.is_owned = false;
32130 int64_t ret_conv = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
32134 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_max_fee_satoshis"))) TS_ClosingSignedFeeRange_set_max_fee_satoshis(uint64_t this_ptr, int64_t val) {
32135 LDKClosingSignedFeeRange this_ptr_conv;
32136 this_ptr_conv.inner = untag_ptr(this_ptr);
32137 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32139 this_ptr_conv.is_owned = false;
32140 ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
32143 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_new"))) TS_ClosingSignedFeeRange_new(int64_t min_fee_satoshis_arg, int64_t max_fee_satoshis_arg) {
32144 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
32145 uint64_t ret_ref = 0;
32146 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32147 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32151 static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
32152 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
32153 uint64_t ret_ref = 0;
32154 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32155 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32158 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone_ptr"))) TS_ClosingSignedFeeRange_clone_ptr(uint64_t arg) {
32159 LDKClosingSignedFeeRange arg_conv;
32160 arg_conv.inner = untag_ptr(arg);
32161 arg_conv.is_owned = ptr_is_owned(arg);
32162 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32163 arg_conv.is_owned = false;
32164 int64_t ret_conv = ClosingSignedFeeRange_clone_ptr(&arg_conv);
32168 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone"))) TS_ClosingSignedFeeRange_clone(uint64_t orig) {
32169 LDKClosingSignedFeeRange orig_conv;
32170 orig_conv.inner = untag_ptr(orig);
32171 orig_conv.is_owned = ptr_is_owned(orig);
32172 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32173 orig_conv.is_owned = false;
32174 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
32175 uint64_t ret_ref = 0;
32176 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32177 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32181 jboolean __attribute__((export_name("TS_ClosingSignedFeeRange_eq"))) TS_ClosingSignedFeeRange_eq(uint64_t a, uint64_t b) {
32182 LDKClosingSignedFeeRange a_conv;
32183 a_conv.inner = untag_ptr(a);
32184 a_conv.is_owned = ptr_is_owned(a);
32185 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32186 a_conv.is_owned = false;
32187 LDKClosingSignedFeeRange b_conv;
32188 b_conv.inner = untag_ptr(b);
32189 b_conv.is_owned = ptr_is_owned(b);
32190 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32191 b_conv.is_owned = false;
32192 jboolean ret_conv = ClosingSignedFeeRange_eq(&a_conv, &b_conv);
32196 void __attribute__((export_name("TS_ClosingSigned_free"))) TS_ClosingSigned_free(uint64_t this_obj) {
32197 LDKClosingSigned this_obj_conv;
32198 this_obj_conv.inner = untag_ptr(this_obj);
32199 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32200 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32201 ClosingSigned_free(this_obj_conv);
32204 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_channel_id"))) TS_ClosingSigned_get_channel_id(uint64_t this_ptr) {
32205 LDKClosingSigned this_ptr_conv;
32206 this_ptr_conv.inner = untag_ptr(this_ptr);
32207 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32209 this_ptr_conv.is_owned = false;
32210 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32211 memcpy(ret_arr->elems, *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
32215 void __attribute__((export_name("TS_ClosingSigned_set_channel_id"))) TS_ClosingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32216 LDKClosingSigned this_ptr_conv;
32217 this_ptr_conv.inner = untag_ptr(this_ptr);
32218 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32220 this_ptr_conv.is_owned = false;
32221 LDKThirtyTwoBytes val_ref;
32222 CHECK(val->arr_len == 32);
32223 memcpy(val_ref.data, val->elems, 32); FREE(val);
32224 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
32227 int64_t __attribute__((export_name("TS_ClosingSigned_get_fee_satoshis"))) TS_ClosingSigned_get_fee_satoshis(uint64_t this_ptr) {
32228 LDKClosingSigned 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 int64_t ret_conv = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
32237 void __attribute__((export_name("TS_ClosingSigned_set_fee_satoshis"))) TS_ClosingSigned_set_fee_satoshis(uint64_t this_ptr, int64_t val) {
32238 LDKClosingSigned this_ptr_conv;
32239 this_ptr_conv.inner = untag_ptr(this_ptr);
32240 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32242 this_ptr_conv.is_owned = false;
32243 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
32246 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_signature"))) TS_ClosingSigned_get_signature(uint64_t this_ptr) {
32247 LDKClosingSigned 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 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32253 memcpy(ret_arr->elems, ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
32257 void __attribute__((export_name("TS_ClosingSigned_set_signature"))) TS_ClosingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
32258 LDKClosingSigned this_ptr_conv;
32259 this_ptr_conv.inner = untag_ptr(this_ptr);
32260 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32262 this_ptr_conv.is_owned = false;
32263 LDKSignature val_ref;
32264 CHECK(val->arr_len == 64);
32265 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32266 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
32269 uint64_t __attribute__((export_name("TS_ClosingSigned_get_fee_range"))) TS_ClosingSigned_get_fee_range(uint64_t this_ptr) {
32270 LDKClosingSigned this_ptr_conv;
32271 this_ptr_conv.inner = untag_ptr(this_ptr);
32272 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32274 this_ptr_conv.is_owned = false;
32275 LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
32276 uint64_t ret_ref = 0;
32277 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32278 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32282 void __attribute__((export_name("TS_ClosingSigned_set_fee_range"))) TS_ClosingSigned_set_fee_range(uint64_t this_ptr, uint64_t val) {
32283 LDKClosingSigned this_ptr_conv;
32284 this_ptr_conv.inner = untag_ptr(this_ptr);
32285 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32287 this_ptr_conv.is_owned = false;
32288 LDKClosingSignedFeeRange val_conv;
32289 val_conv.inner = untag_ptr(val);
32290 val_conv.is_owned = ptr_is_owned(val);
32291 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
32292 val_conv = ClosingSignedFeeRange_clone(&val_conv);
32293 ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
32296 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) {
32297 LDKThirtyTwoBytes channel_id_arg_ref;
32298 CHECK(channel_id_arg->arr_len == 32);
32299 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32300 LDKSignature signature_arg_ref;
32301 CHECK(signature_arg->arr_len == 64);
32302 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
32303 LDKClosingSignedFeeRange fee_range_arg_conv;
32304 fee_range_arg_conv.inner = untag_ptr(fee_range_arg);
32305 fee_range_arg_conv.is_owned = ptr_is_owned(fee_range_arg);
32306 CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
32307 fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
32308 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
32309 uint64_t ret_ref = 0;
32310 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32311 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32315 static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
32316 LDKClosingSigned ret_var = ClosingSigned_clone(arg);
32317 uint64_t ret_ref = 0;
32318 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32319 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32322 int64_t __attribute__((export_name("TS_ClosingSigned_clone_ptr"))) TS_ClosingSigned_clone_ptr(uint64_t arg) {
32323 LDKClosingSigned arg_conv;
32324 arg_conv.inner = untag_ptr(arg);
32325 arg_conv.is_owned = ptr_is_owned(arg);
32326 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32327 arg_conv.is_owned = false;
32328 int64_t ret_conv = ClosingSigned_clone_ptr(&arg_conv);
32332 uint64_t __attribute__((export_name("TS_ClosingSigned_clone"))) TS_ClosingSigned_clone(uint64_t orig) {
32333 LDKClosingSigned orig_conv;
32334 orig_conv.inner = untag_ptr(orig);
32335 orig_conv.is_owned = ptr_is_owned(orig);
32336 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32337 orig_conv.is_owned = false;
32338 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
32339 uint64_t ret_ref = 0;
32340 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32341 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32345 jboolean __attribute__((export_name("TS_ClosingSigned_eq"))) TS_ClosingSigned_eq(uint64_t a, uint64_t b) {
32346 LDKClosingSigned a_conv;
32347 a_conv.inner = untag_ptr(a);
32348 a_conv.is_owned = ptr_is_owned(a);
32349 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32350 a_conv.is_owned = false;
32351 LDKClosingSigned b_conv;
32352 b_conv.inner = untag_ptr(b);
32353 b_conv.is_owned = ptr_is_owned(b);
32354 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32355 b_conv.is_owned = false;
32356 jboolean ret_conv = ClosingSigned_eq(&a_conv, &b_conv);
32360 void __attribute__((export_name("TS_UpdateAddHTLC_free"))) TS_UpdateAddHTLC_free(uint64_t this_obj) {
32361 LDKUpdateAddHTLC this_obj_conv;
32362 this_obj_conv.inner = untag_ptr(this_obj);
32363 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32365 UpdateAddHTLC_free(this_obj_conv);
32368 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_channel_id"))) TS_UpdateAddHTLC_get_channel_id(uint64_t this_ptr) {
32369 LDKUpdateAddHTLC this_ptr_conv;
32370 this_ptr_conv.inner = untag_ptr(this_ptr);
32371 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32372 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32373 this_ptr_conv.is_owned = false;
32374 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32375 memcpy(ret_arr->elems, *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
32379 void __attribute__((export_name("TS_UpdateAddHTLC_set_channel_id"))) TS_UpdateAddHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32380 LDKUpdateAddHTLC this_ptr_conv;
32381 this_ptr_conv.inner = untag_ptr(this_ptr);
32382 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32384 this_ptr_conv.is_owned = false;
32385 LDKThirtyTwoBytes val_ref;
32386 CHECK(val->arr_len == 32);
32387 memcpy(val_ref.data, val->elems, 32); FREE(val);
32388 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
32391 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_htlc_id"))) TS_UpdateAddHTLC_get_htlc_id(uint64_t this_ptr) {
32392 LDKUpdateAddHTLC this_ptr_conv;
32393 this_ptr_conv.inner = untag_ptr(this_ptr);
32394 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32395 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32396 this_ptr_conv.is_owned = false;
32397 int64_t ret_conv = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
32401 void __attribute__((export_name("TS_UpdateAddHTLC_set_htlc_id"))) TS_UpdateAddHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32402 LDKUpdateAddHTLC this_ptr_conv;
32403 this_ptr_conv.inner = untag_ptr(this_ptr);
32404 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32406 this_ptr_conv.is_owned = false;
32407 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
32410 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_amount_msat"))) TS_UpdateAddHTLC_get_amount_msat(uint64_t this_ptr) {
32411 LDKUpdateAddHTLC this_ptr_conv;
32412 this_ptr_conv.inner = untag_ptr(this_ptr);
32413 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32414 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32415 this_ptr_conv.is_owned = false;
32416 int64_t ret_conv = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
32420 void __attribute__((export_name("TS_UpdateAddHTLC_set_amount_msat"))) TS_UpdateAddHTLC_set_amount_msat(uint64_t this_ptr, int64_t val) {
32421 LDKUpdateAddHTLC this_ptr_conv;
32422 this_ptr_conv.inner = untag_ptr(this_ptr);
32423 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32424 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32425 this_ptr_conv.is_owned = false;
32426 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
32429 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_payment_hash"))) TS_UpdateAddHTLC_get_payment_hash(uint64_t this_ptr) {
32430 LDKUpdateAddHTLC this_ptr_conv;
32431 this_ptr_conv.inner = untag_ptr(this_ptr);
32432 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32434 this_ptr_conv.is_owned = false;
32435 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32436 memcpy(ret_arr->elems, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
32440 void __attribute__((export_name("TS_UpdateAddHTLC_set_payment_hash"))) TS_UpdateAddHTLC_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
32441 LDKUpdateAddHTLC this_ptr_conv;
32442 this_ptr_conv.inner = untag_ptr(this_ptr);
32443 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32444 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32445 this_ptr_conv.is_owned = false;
32446 LDKThirtyTwoBytes val_ref;
32447 CHECK(val->arr_len == 32);
32448 memcpy(val_ref.data, val->elems, 32); FREE(val);
32449 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
32452 int32_t __attribute__((export_name("TS_UpdateAddHTLC_get_cltv_expiry"))) TS_UpdateAddHTLC_get_cltv_expiry(uint64_t this_ptr) {
32453 LDKUpdateAddHTLC this_ptr_conv;
32454 this_ptr_conv.inner = untag_ptr(this_ptr);
32455 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32456 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32457 this_ptr_conv.is_owned = false;
32458 int32_t ret_conv = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
32462 void __attribute__((export_name("TS_UpdateAddHTLC_set_cltv_expiry"))) TS_UpdateAddHTLC_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
32463 LDKUpdateAddHTLC this_ptr_conv;
32464 this_ptr_conv.inner = untag_ptr(this_ptr);
32465 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32467 this_ptr_conv.is_owned = false;
32468 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
32471 static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
32472 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
32473 uint64_t ret_ref = 0;
32474 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32475 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32478 int64_t __attribute__((export_name("TS_UpdateAddHTLC_clone_ptr"))) TS_UpdateAddHTLC_clone_ptr(uint64_t arg) {
32479 LDKUpdateAddHTLC arg_conv;
32480 arg_conv.inner = untag_ptr(arg);
32481 arg_conv.is_owned = ptr_is_owned(arg);
32482 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32483 arg_conv.is_owned = false;
32484 int64_t ret_conv = UpdateAddHTLC_clone_ptr(&arg_conv);
32488 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_clone"))) TS_UpdateAddHTLC_clone(uint64_t orig) {
32489 LDKUpdateAddHTLC orig_conv;
32490 orig_conv.inner = untag_ptr(orig);
32491 orig_conv.is_owned = ptr_is_owned(orig);
32492 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32493 orig_conv.is_owned = false;
32494 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
32495 uint64_t ret_ref = 0;
32496 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32497 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32501 jboolean __attribute__((export_name("TS_UpdateAddHTLC_eq"))) TS_UpdateAddHTLC_eq(uint64_t a, uint64_t b) {
32502 LDKUpdateAddHTLC a_conv;
32503 a_conv.inner = untag_ptr(a);
32504 a_conv.is_owned = ptr_is_owned(a);
32505 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32506 a_conv.is_owned = false;
32507 LDKUpdateAddHTLC b_conv;
32508 b_conv.inner = untag_ptr(b);
32509 b_conv.is_owned = ptr_is_owned(b);
32510 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32511 b_conv.is_owned = false;
32512 jboolean ret_conv = UpdateAddHTLC_eq(&a_conv, &b_conv);
32516 void __attribute__((export_name("TS_OnionMessage_free"))) TS_OnionMessage_free(uint64_t this_obj) {
32517 LDKOnionMessage this_obj_conv;
32518 this_obj_conv.inner = untag_ptr(this_obj);
32519 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32521 OnionMessage_free(this_obj_conv);
32524 int8_tArray __attribute__((export_name("TS_OnionMessage_get_blinding_point"))) TS_OnionMessage_get_blinding_point(uint64_t this_ptr) {
32525 LDKOnionMessage this_ptr_conv;
32526 this_ptr_conv.inner = untag_ptr(this_ptr);
32527 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32528 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32529 this_ptr_conv.is_owned = false;
32530 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
32531 memcpy(ret_arr->elems, OnionMessage_get_blinding_point(&this_ptr_conv).compressed_form, 33);
32535 void __attribute__((export_name("TS_OnionMessage_set_blinding_point"))) TS_OnionMessage_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
32536 LDKOnionMessage this_ptr_conv;
32537 this_ptr_conv.inner = untag_ptr(this_ptr);
32538 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32540 this_ptr_conv.is_owned = false;
32541 LDKPublicKey val_ref;
32542 CHECK(val->arr_len == 33);
32543 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
32544 OnionMessage_set_blinding_point(&this_ptr_conv, val_ref);
32547 static inline uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg) {
32548 LDKOnionMessage ret_var = OnionMessage_clone(arg);
32549 uint64_t ret_ref = 0;
32550 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32551 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32554 int64_t __attribute__((export_name("TS_OnionMessage_clone_ptr"))) TS_OnionMessage_clone_ptr(uint64_t arg) {
32555 LDKOnionMessage arg_conv;
32556 arg_conv.inner = untag_ptr(arg);
32557 arg_conv.is_owned = ptr_is_owned(arg);
32558 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32559 arg_conv.is_owned = false;
32560 int64_t ret_conv = OnionMessage_clone_ptr(&arg_conv);
32564 uint64_t __attribute__((export_name("TS_OnionMessage_clone"))) TS_OnionMessage_clone(uint64_t orig) {
32565 LDKOnionMessage orig_conv;
32566 orig_conv.inner = untag_ptr(orig);
32567 orig_conv.is_owned = ptr_is_owned(orig);
32568 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32569 orig_conv.is_owned = false;
32570 LDKOnionMessage ret_var = OnionMessage_clone(&orig_conv);
32571 uint64_t ret_ref = 0;
32572 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32573 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32577 jboolean __attribute__((export_name("TS_OnionMessage_eq"))) TS_OnionMessage_eq(uint64_t a, uint64_t b) {
32578 LDKOnionMessage a_conv;
32579 a_conv.inner = untag_ptr(a);
32580 a_conv.is_owned = ptr_is_owned(a);
32581 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32582 a_conv.is_owned = false;
32583 LDKOnionMessage b_conv;
32584 b_conv.inner = untag_ptr(b);
32585 b_conv.is_owned = ptr_is_owned(b);
32586 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32587 b_conv.is_owned = false;
32588 jboolean ret_conv = OnionMessage_eq(&a_conv, &b_conv);
32592 void __attribute__((export_name("TS_UpdateFulfillHTLC_free"))) TS_UpdateFulfillHTLC_free(uint64_t this_obj) {
32593 LDKUpdateFulfillHTLC this_obj_conv;
32594 this_obj_conv.inner = untag_ptr(this_obj);
32595 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32596 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32597 UpdateFulfillHTLC_free(this_obj_conv);
32600 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_channel_id"))) TS_UpdateFulfillHTLC_get_channel_id(uint64_t this_ptr) {
32601 LDKUpdateFulfillHTLC this_ptr_conv;
32602 this_ptr_conv.inner = untag_ptr(this_ptr);
32603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32605 this_ptr_conv.is_owned = false;
32606 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32607 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
32611 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_channel_id"))) TS_UpdateFulfillHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32612 LDKUpdateFulfillHTLC this_ptr_conv;
32613 this_ptr_conv.inner = untag_ptr(this_ptr);
32614 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32616 this_ptr_conv.is_owned = false;
32617 LDKThirtyTwoBytes val_ref;
32618 CHECK(val->arr_len == 32);
32619 memcpy(val_ref.data, val->elems, 32); FREE(val);
32620 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
32623 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_get_htlc_id"))) TS_UpdateFulfillHTLC_get_htlc_id(uint64_t this_ptr) {
32624 LDKUpdateFulfillHTLC this_ptr_conv;
32625 this_ptr_conv.inner = untag_ptr(this_ptr);
32626 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32628 this_ptr_conv.is_owned = false;
32629 int64_t ret_conv = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
32633 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_htlc_id"))) TS_UpdateFulfillHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32634 LDKUpdateFulfillHTLC this_ptr_conv;
32635 this_ptr_conv.inner = untag_ptr(this_ptr);
32636 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32637 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32638 this_ptr_conv.is_owned = false;
32639 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
32642 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_payment_preimage"))) TS_UpdateFulfillHTLC_get_payment_preimage(uint64_t this_ptr) {
32643 LDKUpdateFulfillHTLC 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 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32649 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
32653 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_payment_preimage"))) TS_UpdateFulfillHTLC_set_payment_preimage(uint64_t this_ptr, int8_tArray val) {
32654 LDKUpdateFulfillHTLC this_ptr_conv;
32655 this_ptr_conv.inner = untag_ptr(this_ptr);
32656 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32658 this_ptr_conv.is_owned = false;
32659 LDKThirtyTwoBytes val_ref;
32660 CHECK(val->arr_len == 32);
32661 memcpy(val_ref.data, val->elems, 32); FREE(val);
32662 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
32665 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) {
32666 LDKThirtyTwoBytes channel_id_arg_ref;
32667 CHECK(channel_id_arg->arr_len == 32);
32668 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32669 LDKThirtyTwoBytes payment_preimage_arg_ref;
32670 CHECK(payment_preimage_arg->arr_len == 32);
32671 memcpy(payment_preimage_arg_ref.data, payment_preimage_arg->elems, 32); FREE(payment_preimage_arg);
32672 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
32673 uint64_t ret_ref = 0;
32674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32675 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32679 static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
32680 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
32681 uint64_t ret_ref = 0;
32682 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32683 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32686 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone_ptr"))) TS_UpdateFulfillHTLC_clone_ptr(uint64_t arg) {
32687 LDKUpdateFulfillHTLC arg_conv;
32688 arg_conv.inner = untag_ptr(arg);
32689 arg_conv.is_owned = ptr_is_owned(arg);
32690 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32691 arg_conv.is_owned = false;
32692 int64_t ret_conv = UpdateFulfillHTLC_clone_ptr(&arg_conv);
32696 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone"))) TS_UpdateFulfillHTLC_clone(uint64_t orig) {
32697 LDKUpdateFulfillHTLC orig_conv;
32698 orig_conv.inner = untag_ptr(orig);
32699 orig_conv.is_owned = ptr_is_owned(orig);
32700 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32701 orig_conv.is_owned = false;
32702 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
32703 uint64_t ret_ref = 0;
32704 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32705 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32709 jboolean __attribute__((export_name("TS_UpdateFulfillHTLC_eq"))) TS_UpdateFulfillHTLC_eq(uint64_t a, uint64_t b) {
32710 LDKUpdateFulfillHTLC a_conv;
32711 a_conv.inner = untag_ptr(a);
32712 a_conv.is_owned = ptr_is_owned(a);
32713 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32714 a_conv.is_owned = false;
32715 LDKUpdateFulfillHTLC b_conv;
32716 b_conv.inner = untag_ptr(b);
32717 b_conv.is_owned = ptr_is_owned(b);
32718 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32719 b_conv.is_owned = false;
32720 jboolean ret_conv = UpdateFulfillHTLC_eq(&a_conv, &b_conv);
32724 void __attribute__((export_name("TS_UpdateFailHTLC_free"))) TS_UpdateFailHTLC_free(uint64_t this_obj) {
32725 LDKUpdateFailHTLC this_obj_conv;
32726 this_obj_conv.inner = untag_ptr(this_obj);
32727 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32729 UpdateFailHTLC_free(this_obj_conv);
32732 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_get_channel_id"))) TS_UpdateFailHTLC_get_channel_id(uint64_t this_ptr) {
32733 LDKUpdateFailHTLC this_ptr_conv;
32734 this_ptr_conv.inner = untag_ptr(this_ptr);
32735 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32737 this_ptr_conv.is_owned = false;
32738 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32739 memcpy(ret_arr->elems, *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
32743 void __attribute__((export_name("TS_UpdateFailHTLC_set_channel_id"))) TS_UpdateFailHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32744 LDKUpdateFailHTLC this_ptr_conv;
32745 this_ptr_conv.inner = untag_ptr(this_ptr);
32746 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32747 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32748 this_ptr_conv.is_owned = false;
32749 LDKThirtyTwoBytes val_ref;
32750 CHECK(val->arr_len == 32);
32751 memcpy(val_ref.data, val->elems, 32); FREE(val);
32752 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
32755 int64_t __attribute__((export_name("TS_UpdateFailHTLC_get_htlc_id"))) TS_UpdateFailHTLC_get_htlc_id(uint64_t this_ptr) {
32756 LDKUpdateFailHTLC this_ptr_conv;
32757 this_ptr_conv.inner = untag_ptr(this_ptr);
32758 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32759 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32760 this_ptr_conv.is_owned = false;
32761 int64_t ret_conv = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
32765 void __attribute__((export_name("TS_UpdateFailHTLC_set_htlc_id"))) TS_UpdateFailHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32766 LDKUpdateFailHTLC this_ptr_conv;
32767 this_ptr_conv.inner = untag_ptr(this_ptr);
32768 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32770 this_ptr_conv.is_owned = false;
32771 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
32774 static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
32775 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
32776 uint64_t ret_ref = 0;
32777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32781 int64_t __attribute__((export_name("TS_UpdateFailHTLC_clone_ptr"))) TS_UpdateFailHTLC_clone_ptr(uint64_t arg) {
32782 LDKUpdateFailHTLC arg_conv;
32783 arg_conv.inner = untag_ptr(arg);
32784 arg_conv.is_owned = ptr_is_owned(arg);
32785 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32786 arg_conv.is_owned = false;
32787 int64_t ret_conv = UpdateFailHTLC_clone_ptr(&arg_conv);
32791 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_clone"))) TS_UpdateFailHTLC_clone(uint64_t orig) {
32792 LDKUpdateFailHTLC orig_conv;
32793 orig_conv.inner = untag_ptr(orig);
32794 orig_conv.is_owned = ptr_is_owned(orig);
32795 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32796 orig_conv.is_owned = false;
32797 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
32798 uint64_t ret_ref = 0;
32799 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32800 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32804 jboolean __attribute__((export_name("TS_UpdateFailHTLC_eq"))) TS_UpdateFailHTLC_eq(uint64_t a, uint64_t b) {
32805 LDKUpdateFailHTLC a_conv;
32806 a_conv.inner = untag_ptr(a);
32807 a_conv.is_owned = ptr_is_owned(a);
32808 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32809 a_conv.is_owned = false;
32810 LDKUpdateFailHTLC b_conv;
32811 b_conv.inner = untag_ptr(b);
32812 b_conv.is_owned = ptr_is_owned(b);
32813 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32814 b_conv.is_owned = false;
32815 jboolean ret_conv = UpdateFailHTLC_eq(&a_conv, &b_conv);
32819 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_free"))) TS_UpdateFailMalformedHTLC_free(uint64_t this_obj) {
32820 LDKUpdateFailMalformedHTLC this_obj_conv;
32821 this_obj_conv.inner = untag_ptr(this_obj);
32822 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32824 UpdateFailMalformedHTLC_free(this_obj_conv);
32827 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_channel_id"))) TS_UpdateFailMalformedHTLC_get_channel_id(uint64_t this_ptr) {
32828 LDKUpdateFailMalformedHTLC this_ptr_conv;
32829 this_ptr_conv.inner = untag_ptr(this_ptr);
32830 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32832 this_ptr_conv.is_owned = false;
32833 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32834 memcpy(ret_arr->elems, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
32838 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_channel_id"))) TS_UpdateFailMalformedHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32839 LDKUpdateFailMalformedHTLC 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 LDKThirtyTwoBytes val_ref;
32845 CHECK(val->arr_len == 32);
32846 memcpy(val_ref.data, val->elems, 32); FREE(val);
32847 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
32850 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_htlc_id"))) TS_UpdateFailMalformedHTLC_get_htlc_id(uint64_t this_ptr) {
32851 LDKUpdateFailMalformedHTLC this_ptr_conv;
32852 this_ptr_conv.inner = untag_ptr(this_ptr);
32853 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32854 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32855 this_ptr_conv.is_owned = false;
32856 int64_t ret_conv = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
32860 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_htlc_id"))) TS_UpdateFailMalformedHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32861 LDKUpdateFailMalformedHTLC this_ptr_conv;
32862 this_ptr_conv.inner = untag_ptr(this_ptr);
32863 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32865 this_ptr_conv.is_owned = false;
32866 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
32869 int16_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_failure_code"))) TS_UpdateFailMalformedHTLC_get_failure_code(uint64_t this_ptr) {
32870 LDKUpdateFailMalformedHTLC this_ptr_conv;
32871 this_ptr_conv.inner = untag_ptr(this_ptr);
32872 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32874 this_ptr_conv.is_owned = false;
32875 int16_t ret_conv = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
32879 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_failure_code"))) TS_UpdateFailMalformedHTLC_set_failure_code(uint64_t this_ptr, int16_t val) {
32880 LDKUpdateFailMalformedHTLC this_ptr_conv;
32881 this_ptr_conv.inner = untag_ptr(this_ptr);
32882 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32883 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32884 this_ptr_conv.is_owned = false;
32885 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
32888 static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
32889 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
32890 uint64_t ret_ref = 0;
32891 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32892 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32895 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone_ptr"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint64_t arg) {
32896 LDKUpdateFailMalformedHTLC arg_conv;
32897 arg_conv.inner = untag_ptr(arg);
32898 arg_conv.is_owned = ptr_is_owned(arg);
32899 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32900 arg_conv.is_owned = false;
32901 int64_t ret_conv = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
32905 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone"))) TS_UpdateFailMalformedHTLC_clone(uint64_t orig) {
32906 LDKUpdateFailMalformedHTLC orig_conv;
32907 orig_conv.inner = untag_ptr(orig);
32908 orig_conv.is_owned = ptr_is_owned(orig);
32909 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32910 orig_conv.is_owned = false;
32911 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
32912 uint64_t ret_ref = 0;
32913 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32914 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32918 jboolean __attribute__((export_name("TS_UpdateFailMalformedHTLC_eq"))) TS_UpdateFailMalformedHTLC_eq(uint64_t a, uint64_t b) {
32919 LDKUpdateFailMalformedHTLC a_conv;
32920 a_conv.inner = untag_ptr(a);
32921 a_conv.is_owned = ptr_is_owned(a);
32922 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32923 a_conv.is_owned = false;
32924 LDKUpdateFailMalformedHTLC b_conv;
32925 b_conv.inner = untag_ptr(b);
32926 b_conv.is_owned = ptr_is_owned(b);
32927 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32928 b_conv.is_owned = false;
32929 jboolean ret_conv = UpdateFailMalformedHTLC_eq(&a_conv, &b_conv);
32933 void __attribute__((export_name("TS_CommitmentSigned_free"))) TS_CommitmentSigned_free(uint64_t this_obj) {
32934 LDKCommitmentSigned this_obj_conv;
32935 this_obj_conv.inner = untag_ptr(this_obj);
32936 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32938 CommitmentSigned_free(this_obj_conv);
32941 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_channel_id"))) TS_CommitmentSigned_get_channel_id(uint64_t this_ptr) {
32942 LDKCommitmentSigned this_ptr_conv;
32943 this_ptr_conv.inner = untag_ptr(this_ptr);
32944 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32946 this_ptr_conv.is_owned = false;
32947 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32948 memcpy(ret_arr->elems, *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
32952 void __attribute__((export_name("TS_CommitmentSigned_set_channel_id"))) TS_CommitmentSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32953 LDKCommitmentSigned 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 LDKThirtyTwoBytes val_ref;
32959 CHECK(val->arr_len == 32);
32960 memcpy(val_ref.data, val->elems, 32); FREE(val);
32961 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
32964 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_signature"))) TS_CommitmentSigned_get_signature(uint64_t this_ptr) {
32965 LDKCommitmentSigned this_ptr_conv;
32966 this_ptr_conv.inner = untag_ptr(this_ptr);
32967 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32969 this_ptr_conv.is_owned = false;
32970 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32971 memcpy(ret_arr->elems, CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
32975 void __attribute__((export_name("TS_CommitmentSigned_set_signature"))) TS_CommitmentSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
32976 LDKCommitmentSigned 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 LDKSignature val_ref;
32982 CHECK(val->arr_len == 64);
32983 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32984 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
32987 ptrArray __attribute__((export_name("TS_CommitmentSigned_get_htlc_signatures"))) TS_CommitmentSigned_get_htlc_signatures(uint64_t this_ptr) {
32988 LDKCommitmentSigned this_ptr_conv;
32989 this_ptr_conv.inner = untag_ptr(this_ptr);
32990 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32992 this_ptr_conv.is_owned = false;
32993 LDKCVec_SignatureZ ret_var = CommitmentSigned_get_htlc_signatures(&this_ptr_conv);
32994 ptrArray ret_arr = NULL;
32995 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
32996 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
32997 for (size_t m = 0; m < ret_var.datalen; m++) {
32998 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
32999 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
33000 ret_arr_ptr[m] = ret_conv_12_arr;
33003 FREE(ret_var.data);
33007 void __attribute__((export_name("TS_CommitmentSigned_set_htlc_signatures"))) TS_CommitmentSigned_set_htlc_signatures(uint64_t this_ptr, ptrArray val) {
33008 LDKCommitmentSigned this_ptr_conv;
33009 this_ptr_conv.inner = untag_ptr(this_ptr);
33010 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33012 this_ptr_conv.is_owned = false;
33013 LDKCVec_SignatureZ val_constr;
33014 val_constr.datalen = val->arr_len;
33015 if (val_constr.datalen > 0)
33016 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
33018 val_constr.data = NULL;
33019 int8_tArray* val_vals = (void*) val->elems;
33020 for (size_t m = 0; m < val_constr.datalen; m++) {
33021 int8_tArray val_conv_12 = val_vals[m];
33022 LDKSignature val_conv_12_ref;
33023 CHECK(val_conv_12->arr_len == 64);
33024 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
33025 val_constr.data[m] = val_conv_12_ref;
33028 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
33031 uint64_t __attribute__((export_name("TS_CommitmentSigned_new"))) TS_CommitmentSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg, ptrArray htlc_signatures_arg) {
33032 LDKThirtyTwoBytes channel_id_arg_ref;
33033 CHECK(channel_id_arg->arr_len == 32);
33034 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33035 LDKSignature signature_arg_ref;
33036 CHECK(signature_arg->arr_len == 64);
33037 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
33038 LDKCVec_SignatureZ htlc_signatures_arg_constr;
33039 htlc_signatures_arg_constr.datalen = htlc_signatures_arg->arr_len;
33040 if (htlc_signatures_arg_constr.datalen > 0)
33041 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
33043 htlc_signatures_arg_constr.data = NULL;
33044 int8_tArray* htlc_signatures_arg_vals = (void*) htlc_signatures_arg->elems;
33045 for (size_t m = 0; m < htlc_signatures_arg_constr.datalen; m++) {
33046 int8_tArray htlc_signatures_arg_conv_12 = htlc_signatures_arg_vals[m];
33047 LDKSignature htlc_signatures_arg_conv_12_ref;
33048 CHECK(htlc_signatures_arg_conv_12->arr_len == 64);
33049 memcpy(htlc_signatures_arg_conv_12_ref.compact_form, htlc_signatures_arg_conv_12->elems, 64); FREE(htlc_signatures_arg_conv_12);
33050 htlc_signatures_arg_constr.data[m] = htlc_signatures_arg_conv_12_ref;
33052 FREE(htlc_signatures_arg);
33053 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
33054 uint64_t ret_ref = 0;
33055 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33056 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33060 static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
33061 LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
33062 uint64_t ret_ref = 0;
33063 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33064 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33067 int64_t __attribute__((export_name("TS_CommitmentSigned_clone_ptr"))) TS_CommitmentSigned_clone_ptr(uint64_t arg) {
33068 LDKCommitmentSigned arg_conv;
33069 arg_conv.inner = untag_ptr(arg);
33070 arg_conv.is_owned = ptr_is_owned(arg);
33071 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33072 arg_conv.is_owned = false;
33073 int64_t ret_conv = CommitmentSigned_clone_ptr(&arg_conv);
33077 uint64_t __attribute__((export_name("TS_CommitmentSigned_clone"))) TS_CommitmentSigned_clone(uint64_t orig) {
33078 LDKCommitmentSigned orig_conv;
33079 orig_conv.inner = untag_ptr(orig);
33080 orig_conv.is_owned = ptr_is_owned(orig);
33081 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33082 orig_conv.is_owned = false;
33083 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
33084 uint64_t ret_ref = 0;
33085 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33086 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33090 jboolean __attribute__((export_name("TS_CommitmentSigned_eq"))) TS_CommitmentSigned_eq(uint64_t a, uint64_t b) {
33091 LDKCommitmentSigned a_conv;
33092 a_conv.inner = untag_ptr(a);
33093 a_conv.is_owned = ptr_is_owned(a);
33094 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33095 a_conv.is_owned = false;
33096 LDKCommitmentSigned b_conv;
33097 b_conv.inner = untag_ptr(b);
33098 b_conv.is_owned = ptr_is_owned(b);
33099 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33100 b_conv.is_owned = false;
33101 jboolean ret_conv = CommitmentSigned_eq(&a_conv, &b_conv);
33105 void __attribute__((export_name("TS_RevokeAndACK_free"))) TS_RevokeAndACK_free(uint64_t this_obj) {
33106 LDKRevokeAndACK this_obj_conv;
33107 this_obj_conv.inner = untag_ptr(this_obj);
33108 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33110 RevokeAndACK_free(this_obj_conv);
33113 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_channel_id"))) TS_RevokeAndACK_get_channel_id(uint64_t this_ptr) {
33114 LDKRevokeAndACK this_ptr_conv;
33115 this_ptr_conv.inner = untag_ptr(this_ptr);
33116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33118 this_ptr_conv.is_owned = false;
33119 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33120 memcpy(ret_arr->elems, *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
33124 void __attribute__((export_name("TS_RevokeAndACK_set_channel_id"))) TS_RevokeAndACK_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33125 LDKRevokeAndACK this_ptr_conv;
33126 this_ptr_conv.inner = untag_ptr(this_ptr);
33127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33129 this_ptr_conv.is_owned = false;
33130 LDKThirtyTwoBytes val_ref;
33131 CHECK(val->arr_len == 32);
33132 memcpy(val_ref.data, val->elems, 32); FREE(val);
33133 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
33136 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_per_commitment_secret"))) TS_RevokeAndACK_get_per_commitment_secret(uint64_t this_ptr) {
33137 LDKRevokeAndACK this_ptr_conv;
33138 this_ptr_conv.inner = untag_ptr(this_ptr);
33139 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33141 this_ptr_conv.is_owned = false;
33142 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33143 memcpy(ret_arr->elems, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
33147 void __attribute__((export_name("TS_RevokeAndACK_set_per_commitment_secret"))) TS_RevokeAndACK_set_per_commitment_secret(uint64_t this_ptr, int8_tArray val) {
33148 LDKRevokeAndACK this_ptr_conv;
33149 this_ptr_conv.inner = untag_ptr(this_ptr);
33150 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33152 this_ptr_conv.is_owned = false;
33153 LDKThirtyTwoBytes val_ref;
33154 CHECK(val->arr_len == 32);
33155 memcpy(val_ref.data, val->elems, 32); FREE(val);
33156 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
33159 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_next_per_commitment_point"))) TS_RevokeAndACK_get_next_per_commitment_point(uint64_t this_ptr) {
33160 LDKRevokeAndACK this_ptr_conv;
33161 this_ptr_conv.inner = untag_ptr(this_ptr);
33162 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33164 this_ptr_conv.is_owned = false;
33165 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33166 memcpy(ret_arr->elems, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
33170 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) {
33171 LDKRevokeAndACK this_ptr_conv;
33172 this_ptr_conv.inner = untag_ptr(this_ptr);
33173 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33175 this_ptr_conv.is_owned = false;
33176 LDKPublicKey val_ref;
33177 CHECK(val->arr_len == 33);
33178 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33179 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
33182 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) {
33183 LDKThirtyTwoBytes channel_id_arg_ref;
33184 CHECK(channel_id_arg->arr_len == 32);
33185 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33186 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
33187 CHECK(per_commitment_secret_arg->arr_len == 32);
33188 memcpy(per_commitment_secret_arg_ref.data, per_commitment_secret_arg->elems, 32); FREE(per_commitment_secret_arg);
33189 LDKPublicKey next_per_commitment_point_arg_ref;
33190 CHECK(next_per_commitment_point_arg->arr_len == 33);
33191 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
33192 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
33193 uint64_t ret_ref = 0;
33194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33195 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33199 static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
33200 LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
33201 uint64_t ret_ref = 0;
33202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33206 int64_t __attribute__((export_name("TS_RevokeAndACK_clone_ptr"))) TS_RevokeAndACK_clone_ptr(uint64_t arg) {
33207 LDKRevokeAndACK arg_conv;
33208 arg_conv.inner = untag_ptr(arg);
33209 arg_conv.is_owned = ptr_is_owned(arg);
33210 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33211 arg_conv.is_owned = false;
33212 int64_t ret_conv = RevokeAndACK_clone_ptr(&arg_conv);
33216 uint64_t __attribute__((export_name("TS_RevokeAndACK_clone"))) TS_RevokeAndACK_clone(uint64_t orig) {
33217 LDKRevokeAndACK orig_conv;
33218 orig_conv.inner = untag_ptr(orig);
33219 orig_conv.is_owned = ptr_is_owned(orig);
33220 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33221 orig_conv.is_owned = false;
33222 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
33223 uint64_t ret_ref = 0;
33224 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33225 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33229 jboolean __attribute__((export_name("TS_RevokeAndACK_eq"))) TS_RevokeAndACK_eq(uint64_t a, uint64_t b) {
33230 LDKRevokeAndACK a_conv;
33231 a_conv.inner = untag_ptr(a);
33232 a_conv.is_owned = ptr_is_owned(a);
33233 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33234 a_conv.is_owned = false;
33235 LDKRevokeAndACK b_conv;
33236 b_conv.inner = untag_ptr(b);
33237 b_conv.is_owned = ptr_is_owned(b);
33238 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33239 b_conv.is_owned = false;
33240 jboolean ret_conv = RevokeAndACK_eq(&a_conv, &b_conv);
33244 void __attribute__((export_name("TS_UpdateFee_free"))) TS_UpdateFee_free(uint64_t this_obj) {
33245 LDKUpdateFee this_obj_conv;
33246 this_obj_conv.inner = untag_ptr(this_obj);
33247 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33249 UpdateFee_free(this_obj_conv);
33252 int8_tArray __attribute__((export_name("TS_UpdateFee_get_channel_id"))) TS_UpdateFee_get_channel_id(uint64_t this_ptr) {
33253 LDKUpdateFee this_ptr_conv;
33254 this_ptr_conv.inner = untag_ptr(this_ptr);
33255 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33257 this_ptr_conv.is_owned = false;
33258 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33259 memcpy(ret_arr->elems, *UpdateFee_get_channel_id(&this_ptr_conv), 32);
33263 void __attribute__((export_name("TS_UpdateFee_set_channel_id"))) TS_UpdateFee_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33264 LDKUpdateFee 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 LDKThirtyTwoBytes val_ref;
33270 CHECK(val->arr_len == 32);
33271 memcpy(val_ref.data, val->elems, 32); FREE(val);
33272 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
33275 int32_t __attribute__((export_name("TS_UpdateFee_get_feerate_per_kw"))) TS_UpdateFee_get_feerate_per_kw(uint64_t this_ptr) {
33276 LDKUpdateFee this_ptr_conv;
33277 this_ptr_conv.inner = untag_ptr(this_ptr);
33278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33280 this_ptr_conv.is_owned = false;
33281 int32_t ret_conv = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
33285 void __attribute__((export_name("TS_UpdateFee_set_feerate_per_kw"))) TS_UpdateFee_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
33286 LDKUpdateFee this_ptr_conv;
33287 this_ptr_conv.inner = untag_ptr(this_ptr);
33288 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33290 this_ptr_conv.is_owned = false;
33291 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
33294 uint64_t __attribute__((export_name("TS_UpdateFee_new"))) TS_UpdateFee_new(int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
33295 LDKThirtyTwoBytes channel_id_arg_ref;
33296 CHECK(channel_id_arg->arr_len == 32);
33297 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33298 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
33299 uint64_t ret_ref = 0;
33300 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33301 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33305 static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
33306 LDKUpdateFee ret_var = UpdateFee_clone(arg);
33307 uint64_t ret_ref = 0;
33308 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33309 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33312 int64_t __attribute__((export_name("TS_UpdateFee_clone_ptr"))) TS_UpdateFee_clone_ptr(uint64_t arg) {
33313 LDKUpdateFee arg_conv;
33314 arg_conv.inner = untag_ptr(arg);
33315 arg_conv.is_owned = ptr_is_owned(arg);
33316 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33317 arg_conv.is_owned = false;
33318 int64_t ret_conv = UpdateFee_clone_ptr(&arg_conv);
33322 uint64_t __attribute__((export_name("TS_UpdateFee_clone"))) TS_UpdateFee_clone(uint64_t orig) {
33323 LDKUpdateFee orig_conv;
33324 orig_conv.inner = untag_ptr(orig);
33325 orig_conv.is_owned = ptr_is_owned(orig);
33326 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33327 orig_conv.is_owned = false;
33328 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
33329 uint64_t ret_ref = 0;
33330 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33331 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33335 jboolean __attribute__((export_name("TS_UpdateFee_eq"))) TS_UpdateFee_eq(uint64_t a, uint64_t b) {
33336 LDKUpdateFee a_conv;
33337 a_conv.inner = untag_ptr(a);
33338 a_conv.is_owned = ptr_is_owned(a);
33339 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33340 a_conv.is_owned = false;
33341 LDKUpdateFee b_conv;
33342 b_conv.inner = untag_ptr(b);
33343 b_conv.is_owned = ptr_is_owned(b);
33344 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33345 b_conv.is_owned = false;
33346 jboolean ret_conv = UpdateFee_eq(&a_conv, &b_conv);
33350 void __attribute__((export_name("TS_DataLossProtect_free"))) TS_DataLossProtect_free(uint64_t this_obj) {
33351 LDKDataLossProtect this_obj_conv;
33352 this_obj_conv.inner = untag_ptr(this_obj);
33353 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33354 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33355 DataLossProtect_free(this_obj_conv);
33358 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) {
33359 LDKDataLossProtect this_ptr_conv;
33360 this_ptr_conv.inner = untag_ptr(this_ptr);
33361 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33363 this_ptr_conv.is_owned = false;
33364 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33365 memcpy(ret_arr->elems, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
33369 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) {
33370 LDKDataLossProtect this_ptr_conv;
33371 this_ptr_conv.inner = untag_ptr(this_ptr);
33372 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33374 this_ptr_conv.is_owned = false;
33375 LDKThirtyTwoBytes val_ref;
33376 CHECK(val->arr_len == 32);
33377 memcpy(val_ref.data, val->elems, 32); FREE(val);
33378 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
33381 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) {
33382 LDKDataLossProtect this_ptr_conv;
33383 this_ptr_conv.inner = untag_ptr(this_ptr);
33384 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33386 this_ptr_conv.is_owned = false;
33387 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33388 memcpy(ret_arr->elems, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
33392 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) {
33393 LDKDataLossProtect this_ptr_conv;
33394 this_ptr_conv.inner = untag_ptr(this_ptr);
33395 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33396 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33397 this_ptr_conv.is_owned = false;
33398 LDKPublicKey val_ref;
33399 CHECK(val->arr_len == 33);
33400 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33401 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
33404 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) {
33405 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
33406 CHECK(your_last_per_commitment_secret_arg->arr_len == 32);
33407 memcpy(your_last_per_commitment_secret_arg_ref.data, your_last_per_commitment_secret_arg->elems, 32); FREE(your_last_per_commitment_secret_arg);
33408 LDKPublicKey my_current_per_commitment_point_arg_ref;
33409 CHECK(my_current_per_commitment_point_arg->arr_len == 33);
33410 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);
33411 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
33412 uint64_t ret_ref = 0;
33413 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33414 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33418 static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
33419 LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
33420 uint64_t ret_ref = 0;
33421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33425 int64_t __attribute__((export_name("TS_DataLossProtect_clone_ptr"))) TS_DataLossProtect_clone_ptr(uint64_t arg) {
33426 LDKDataLossProtect arg_conv;
33427 arg_conv.inner = untag_ptr(arg);
33428 arg_conv.is_owned = ptr_is_owned(arg);
33429 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33430 arg_conv.is_owned = false;
33431 int64_t ret_conv = DataLossProtect_clone_ptr(&arg_conv);
33435 uint64_t __attribute__((export_name("TS_DataLossProtect_clone"))) TS_DataLossProtect_clone(uint64_t orig) {
33436 LDKDataLossProtect orig_conv;
33437 orig_conv.inner = untag_ptr(orig);
33438 orig_conv.is_owned = ptr_is_owned(orig);
33439 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33440 orig_conv.is_owned = false;
33441 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
33442 uint64_t ret_ref = 0;
33443 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33444 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33448 jboolean __attribute__((export_name("TS_DataLossProtect_eq"))) TS_DataLossProtect_eq(uint64_t a, uint64_t b) {
33449 LDKDataLossProtect a_conv;
33450 a_conv.inner = untag_ptr(a);
33451 a_conv.is_owned = ptr_is_owned(a);
33452 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33453 a_conv.is_owned = false;
33454 LDKDataLossProtect b_conv;
33455 b_conv.inner = untag_ptr(b);
33456 b_conv.is_owned = ptr_is_owned(b);
33457 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33458 b_conv.is_owned = false;
33459 jboolean ret_conv = DataLossProtect_eq(&a_conv, &b_conv);
33463 void __attribute__((export_name("TS_ChannelReestablish_free"))) TS_ChannelReestablish_free(uint64_t this_obj) {
33464 LDKChannelReestablish this_obj_conv;
33465 this_obj_conv.inner = untag_ptr(this_obj);
33466 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33468 ChannelReestablish_free(this_obj_conv);
33471 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_channel_id"))) TS_ChannelReestablish_get_channel_id(uint64_t this_ptr) {
33472 LDKChannelReestablish this_ptr_conv;
33473 this_ptr_conv.inner = untag_ptr(this_ptr);
33474 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33476 this_ptr_conv.is_owned = false;
33477 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33478 memcpy(ret_arr->elems, *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
33482 void __attribute__((export_name("TS_ChannelReestablish_set_channel_id"))) TS_ChannelReestablish_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33483 LDKChannelReestablish this_ptr_conv;
33484 this_ptr_conv.inner = untag_ptr(this_ptr);
33485 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33487 this_ptr_conv.is_owned = false;
33488 LDKThirtyTwoBytes val_ref;
33489 CHECK(val->arr_len == 32);
33490 memcpy(val_ref.data, val->elems, 32); FREE(val);
33491 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
33494 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_local_commitment_number"))) TS_ChannelReestablish_get_next_local_commitment_number(uint64_t this_ptr) {
33495 LDKChannelReestablish this_ptr_conv;
33496 this_ptr_conv.inner = untag_ptr(this_ptr);
33497 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33499 this_ptr_conv.is_owned = false;
33500 int64_t ret_conv = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
33504 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) {
33505 LDKChannelReestablish this_ptr_conv;
33506 this_ptr_conv.inner = untag_ptr(this_ptr);
33507 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33508 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33509 this_ptr_conv.is_owned = false;
33510 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
33513 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_remote_commitment_number"))) TS_ChannelReestablish_get_next_remote_commitment_number(uint64_t this_ptr) {
33514 LDKChannelReestablish this_ptr_conv;
33515 this_ptr_conv.inner = untag_ptr(this_ptr);
33516 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33518 this_ptr_conv.is_owned = false;
33519 int64_t ret_conv = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
33523 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) {
33524 LDKChannelReestablish this_ptr_conv;
33525 this_ptr_conv.inner = untag_ptr(this_ptr);
33526 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33528 this_ptr_conv.is_owned = false;
33529 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
33532 static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
33533 LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
33534 uint64_t ret_ref = 0;
33535 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33536 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33539 int64_t __attribute__((export_name("TS_ChannelReestablish_clone_ptr"))) TS_ChannelReestablish_clone_ptr(uint64_t arg) {
33540 LDKChannelReestablish arg_conv;
33541 arg_conv.inner = untag_ptr(arg);
33542 arg_conv.is_owned = ptr_is_owned(arg);
33543 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33544 arg_conv.is_owned = false;
33545 int64_t ret_conv = ChannelReestablish_clone_ptr(&arg_conv);
33549 uint64_t __attribute__((export_name("TS_ChannelReestablish_clone"))) TS_ChannelReestablish_clone(uint64_t orig) {
33550 LDKChannelReestablish orig_conv;
33551 orig_conv.inner = untag_ptr(orig);
33552 orig_conv.is_owned = ptr_is_owned(orig);
33553 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33554 orig_conv.is_owned = false;
33555 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
33556 uint64_t ret_ref = 0;
33557 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33558 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33562 jboolean __attribute__((export_name("TS_ChannelReestablish_eq"))) TS_ChannelReestablish_eq(uint64_t a, uint64_t b) {
33563 LDKChannelReestablish a_conv;
33564 a_conv.inner = untag_ptr(a);
33565 a_conv.is_owned = ptr_is_owned(a);
33566 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33567 a_conv.is_owned = false;
33568 LDKChannelReestablish b_conv;
33569 b_conv.inner = untag_ptr(b);
33570 b_conv.is_owned = ptr_is_owned(b);
33571 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33572 b_conv.is_owned = false;
33573 jboolean ret_conv = ChannelReestablish_eq(&a_conv, &b_conv);
33577 void __attribute__((export_name("TS_AnnouncementSignatures_free"))) TS_AnnouncementSignatures_free(uint64_t this_obj) {
33578 LDKAnnouncementSignatures this_obj_conv;
33579 this_obj_conv.inner = untag_ptr(this_obj);
33580 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33582 AnnouncementSignatures_free(this_obj_conv);
33585 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_channel_id"))) TS_AnnouncementSignatures_get_channel_id(uint64_t this_ptr) {
33586 LDKAnnouncementSignatures this_ptr_conv;
33587 this_ptr_conv.inner = untag_ptr(this_ptr);
33588 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33589 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33590 this_ptr_conv.is_owned = false;
33591 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33592 memcpy(ret_arr->elems, *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
33596 void __attribute__((export_name("TS_AnnouncementSignatures_set_channel_id"))) TS_AnnouncementSignatures_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33597 LDKAnnouncementSignatures this_ptr_conv;
33598 this_ptr_conv.inner = untag_ptr(this_ptr);
33599 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33601 this_ptr_conv.is_owned = false;
33602 LDKThirtyTwoBytes val_ref;
33603 CHECK(val->arr_len == 32);
33604 memcpy(val_ref.data, val->elems, 32); FREE(val);
33605 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
33608 int64_t __attribute__((export_name("TS_AnnouncementSignatures_get_short_channel_id"))) TS_AnnouncementSignatures_get_short_channel_id(uint64_t this_ptr) {
33609 LDKAnnouncementSignatures this_ptr_conv;
33610 this_ptr_conv.inner = untag_ptr(this_ptr);
33611 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33613 this_ptr_conv.is_owned = false;
33614 int64_t ret_conv = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
33618 void __attribute__((export_name("TS_AnnouncementSignatures_set_short_channel_id"))) TS_AnnouncementSignatures_set_short_channel_id(uint64_t this_ptr, int64_t val) {
33619 LDKAnnouncementSignatures this_ptr_conv;
33620 this_ptr_conv.inner = untag_ptr(this_ptr);
33621 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33622 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33623 this_ptr_conv.is_owned = false;
33624 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
33627 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_node_signature"))) TS_AnnouncementSignatures_get_node_signature(uint64_t this_ptr) {
33628 LDKAnnouncementSignatures this_ptr_conv;
33629 this_ptr_conv.inner = untag_ptr(this_ptr);
33630 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33632 this_ptr_conv.is_owned = false;
33633 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33634 memcpy(ret_arr->elems, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
33638 void __attribute__((export_name("TS_AnnouncementSignatures_set_node_signature"))) TS_AnnouncementSignatures_set_node_signature(uint64_t this_ptr, int8_tArray val) {
33639 LDKAnnouncementSignatures this_ptr_conv;
33640 this_ptr_conv.inner = untag_ptr(this_ptr);
33641 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33643 this_ptr_conv.is_owned = false;
33644 LDKSignature val_ref;
33645 CHECK(val->arr_len == 64);
33646 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33647 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
33650 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_bitcoin_signature"))) TS_AnnouncementSignatures_get_bitcoin_signature(uint64_t this_ptr) {
33651 LDKAnnouncementSignatures this_ptr_conv;
33652 this_ptr_conv.inner = untag_ptr(this_ptr);
33653 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33654 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33655 this_ptr_conv.is_owned = false;
33656 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33657 memcpy(ret_arr->elems, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
33661 void __attribute__((export_name("TS_AnnouncementSignatures_set_bitcoin_signature"))) TS_AnnouncementSignatures_set_bitcoin_signature(uint64_t this_ptr, int8_tArray val) {
33662 LDKAnnouncementSignatures this_ptr_conv;
33663 this_ptr_conv.inner = untag_ptr(this_ptr);
33664 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33666 this_ptr_conv.is_owned = false;
33667 LDKSignature val_ref;
33668 CHECK(val->arr_len == 64);
33669 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33670 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
33673 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) {
33674 LDKThirtyTwoBytes channel_id_arg_ref;
33675 CHECK(channel_id_arg->arr_len == 32);
33676 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33677 LDKSignature node_signature_arg_ref;
33678 CHECK(node_signature_arg->arr_len == 64);
33679 memcpy(node_signature_arg_ref.compact_form, node_signature_arg->elems, 64); FREE(node_signature_arg);
33680 LDKSignature bitcoin_signature_arg_ref;
33681 CHECK(bitcoin_signature_arg->arr_len == 64);
33682 memcpy(bitcoin_signature_arg_ref.compact_form, bitcoin_signature_arg->elems, 64); FREE(bitcoin_signature_arg);
33683 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
33684 uint64_t ret_ref = 0;
33685 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33686 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33690 static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
33691 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
33692 uint64_t ret_ref = 0;
33693 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33694 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33697 int64_t __attribute__((export_name("TS_AnnouncementSignatures_clone_ptr"))) TS_AnnouncementSignatures_clone_ptr(uint64_t arg) {
33698 LDKAnnouncementSignatures arg_conv;
33699 arg_conv.inner = untag_ptr(arg);
33700 arg_conv.is_owned = ptr_is_owned(arg);
33701 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33702 arg_conv.is_owned = false;
33703 int64_t ret_conv = AnnouncementSignatures_clone_ptr(&arg_conv);
33707 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_clone"))) TS_AnnouncementSignatures_clone(uint64_t orig) {
33708 LDKAnnouncementSignatures orig_conv;
33709 orig_conv.inner = untag_ptr(orig);
33710 orig_conv.is_owned = ptr_is_owned(orig);
33711 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33712 orig_conv.is_owned = false;
33713 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
33714 uint64_t ret_ref = 0;
33715 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33716 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33720 jboolean __attribute__((export_name("TS_AnnouncementSignatures_eq"))) TS_AnnouncementSignatures_eq(uint64_t a, uint64_t b) {
33721 LDKAnnouncementSignatures a_conv;
33722 a_conv.inner = untag_ptr(a);
33723 a_conv.is_owned = ptr_is_owned(a);
33724 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33725 a_conv.is_owned = false;
33726 LDKAnnouncementSignatures b_conv;
33727 b_conv.inner = untag_ptr(b);
33728 b_conv.is_owned = ptr_is_owned(b);
33729 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33730 b_conv.is_owned = false;
33731 jboolean ret_conv = AnnouncementSignatures_eq(&a_conv, &b_conv);
33735 void __attribute__((export_name("TS_NetAddress_free"))) TS_NetAddress_free(uint64_t this_ptr) {
33736 if (!ptr_is_owned(this_ptr)) return;
33737 void* this_ptr_ptr = untag_ptr(this_ptr);
33738 CHECK_ACCESS(this_ptr_ptr);
33739 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(this_ptr_ptr);
33740 FREE(untag_ptr(this_ptr));
33741 NetAddress_free(this_ptr_conv);
33744 static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
33745 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33746 *ret_copy = NetAddress_clone(arg);
33747 uint64_t ret_ref = tag_ptr(ret_copy, true);
33750 int64_t __attribute__((export_name("TS_NetAddress_clone_ptr"))) TS_NetAddress_clone_ptr(uint64_t arg) {
33751 LDKNetAddress* arg_conv = (LDKNetAddress*)untag_ptr(arg);
33752 int64_t ret_conv = NetAddress_clone_ptr(arg_conv);
33756 uint64_t __attribute__((export_name("TS_NetAddress_clone"))) TS_NetAddress_clone(uint64_t orig) {
33757 LDKNetAddress* orig_conv = (LDKNetAddress*)untag_ptr(orig);
33758 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33759 *ret_copy = NetAddress_clone(orig_conv);
33760 uint64_t ret_ref = tag_ptr(ret_copy, true);
33764 uint64_t __attribute__((export_name("TS_NetAddress_ipv4"))) TS_NetAddress_ipv4(int8_tArray addr, int16_t port) {
33765 LDKFourBytes addr_ref;
33766 CHECK(addr->arr_len == 4);
33767 memcpy(addr_ref.data, addr->elems, 4); FREE(addr);
33768 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33769 *ret_copy = NetAddress_ipv4(addr_ref, port);
33770 uint64_t ret_ref = tag_ptr(ret_copy, true);
33774 uint64_t __attribute__((export_name("TS_NetAddress_ipv6"))) TS_NetAddress_ipv6(int8_tArray addr, int16_t port) {
33775 LDKSixteenBytes addr_ref;
33776 CHECK(addr->arr_len == 16);
33777 memcpy(addr_ref.data, addr->elems, 16); FREE(addr);
33778 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33779 *ret_copy = NetAddress_ipv6(addr_ref, port);
33780 uint64_t ret_ref = tag_ptr(ret_copy, true);
33784 uint64_t __attribute__((export_name("TS_NetAddress_onion_v2"))) TS_NetAddress_onion_v2(int8_tArray a) {
33785 LDKTwelveBytes a_ref;
33786 CHECK(a->arr_len == 12);
33787 memcpy(a_ref.data, a->elems, 12); FREE(a);
33788 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33789 *ret_copy = NetAddress_onion_v2(a_ref);
33790 uint64_t ret_ref = tag_ptr(ret_copy, true);
33794 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) {
33795 LDKThirtyTwoBytes ed25519_pubkey_ref;
33796 CHECK(ed25519_pubkey->arr_len == 32);
33797 memcpy(ed25519_pubkey_ref.data, ed25519_pubkey->elems, 32); FREE(ed25519_pubkey);
33798 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33799 *ret_copy = NetAddress_onion_v3(ed25519_pubkey_ref, checksum, version, port);
33800 uint64_t ret_ref = tag_ptr(ret_copy, true);
33804 uint64_t __attribute__((export_name("TS_NetAddress_hostname"))) TS_NetAddress_hostname(uint64_t hostname, int16_t port) {
33805 LDKHostname hostname_conv;
33806 hostname_conv.inner = untag_ptr(hostname);
33807 hostname_conv.is_owned = ptr_is_owned(hostname);
33808 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_conv);
33809 hostname_conv = Hostname_clone(&hostname_conv);
33810 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33811 *ret_copy = NetAddress_hostname(hostname_conv, port);
33812 uint64_t ret_ref = tag_ptr(ret_copy, true);
33816 jboolean __attribute__((export_name("TS_NetAddress_eq"))) TS_NetAddress_eq(uint64_t a, uint64_t b) {
33817 LDKNetAddress* a_conv = (LDKNetAddress*)untag_ptr(a);
33818 LDKNetAddress* b_conv = (LDKNetAddress*)untag_ptr(b);
33819 jboolean ret_conv = NetAddress_eq(a_conv, b_conv);
33823 int8_tArray __attribute__((export_name("TS_NetAddress_write"))) TS_NetAddress_write(uint64_t obj) {
33824 LDKNetAddress* obj_conv = (LDKNetAddress*)untag_ptr(obj);
33825 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
33826 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33827 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33828 CVec_u8Z_free(ret_var);
33832 uint64_t __attribute__((export_name("TS_NetAddress_read"))) TS_NetAddress_read(int8_tArray ser) {
33833 LDKu8slice ser_ref;
33834 ser_ref.datalen = ser->arr_len;
33835 ser_ref.data = ser->elems;
33836 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
33837 *ret_conv = NetAddress_read(ser_ref);
33839 return tag_ptr(ret_conv, true);
33842 void __attribute__((export_name("TS_UnsignedGossipMessage_free"))) TS_UnsignedGossipMessage_free(uint64_t this_ptr) {
33843 if (!ptr_is_owned(this_ptr)) return;
33844 void* this_ptr_ptr = untag_ptr(this_ptr);
33845 CHECK_ACCESS(this_ptr_ptr);
33846 LDKUnsignedGossipMessage this_ptr_conv = *(LDKUnsignedGossipMessage*)(this_ptr_ptr);
33847 FREE(untag_ptr(this_ptr));
33848 UnsignedGossipMessage_free(this_ptr_conv);
33851 static inline uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg) {
33852 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33853 *ret_copy = UnsignedGossipMessage_clone(arg);
33854 uint64_t ret_ref = tag_ptr(ret_copy, true);
33857 int64_t __attribute__((export_name("TS_UnsignedGossipMessage_clone_ptr"))) TS_UnsignedGossipMessage_clone_ptr(uint64_t arg) {
33858 LDKUnsignedGossipMessage* arg_conv = (LDKUnsignedGossipMessage*)untag_ptr(arg);
33859 int64_t ret_conv = UnsignedGossipMessage_clone_ptr(arg_conv);
33863 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_clone"))) TS_UnsignedGossipMessage_clone(uint64_t orig) {
33864 LDKUnsignedGossipMessage* orig_conv = (LDKUnsignedGossipMessage*)untag_ptr(orig);
33865 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33866 *ret_copy = UnsignedGossipMessage_clone(orig_conv);
33867 uint64_t ret_ref = tag_ptr(ret_copy, true);
33871 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_channel_announcement"))) TS_UnsignedGossipMessage_channel_announcement(uint64_t a) {
33872 LDKUnsignedChannelAnnouncement a_conv;
33873 a_conv.inner = untag_ptr(a);
33874 a_conv.is_owned = ptr_is_owned(a);
33875 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33876 a_conv = UnsignedChannelAnnouncement_clone(&a_conv);
33877 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33878 *ret_copy = UnsignedGossipMessage_channel_announcement(a_conv);
33879 uint64_t ret_ref = tag_ptr(ret_copy, true);
33883 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_channel_update"))) TS_UnsignedGossipMessage_channel_update(uint64_t a) {
33884 LDKUnsignedChannelUpdate a_conv;
33885 a_conv.inner = untag_ptr(a);
33886 a_conv.is_owned = ptr_is_owned(a);
33887 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33888 a_conv = UnsignedChannelUpdate_clone(&a_conv);
33889 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33890 *ret_copy = UnsignedGossipMessage_channel_update(a_conv);
33891 uint64_t ret_ref = tag_ptr(ret_copy, true);
33895 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_node_announcement"))) TS_UnsignedGossipMessage_node_announcement(uint64_t a) {
33896 LDKUnsignedNodeAnnouncement a_conv;
33897 a_conv.inner = untag_ptr(a);
33898 a_conv.is_owned = ptr_is_owned(a);
33899 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33900 a_conv = UnsignedNodeAnnouncement_clone(&a_conv);
33901 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33902 *ret_copy = UnsignedGossipMessage_node_announcement(a_conv);
33903 uint64_t ret_ref = tag_ptr(ret_copy, true);
33907 int8_tArray __attribute__((export_name("TS_UnsignedGossipMessage_write"))) TS_UnsignedGossipMessage_write(uint64_t obj) {
33908 LDKUnsignedGossipMessage* obj_conv = (LDKUnsignedGossipMessage*)untag_ptr(obj);
33909 LDKCVec_u8Z ret_var = UnsignedGossipMessage_write(obj_conv);
33910 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33911 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33912 CVec_u8Z_free(ret_var);
33916 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_free"))) TS_UnsignedNodeAnnouncement_free(uint64_t this_obj) {
33917 LDKUnsignedNodeAnnouncement this_obj_conv;
33918 this_obj_conv.inner = untag_ptr(this_obj);
33919 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33921 UnsignedNodeAnnouncement_free(this_obj_conv);
33924 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_features"))) TS_UnsignedNodeAnnouncement_get_features(uint64_t this_ptr) {
33925 LDKUnsignedNodeAnnouncement this_ptr_conv;
33926 this_ptr_conv.inner = untag_ptr(this_ptr);
33927 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33929 this_ptr_conv.is_owned = false;
33930 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
33931 uint64_t ret_ref = 0;
33932 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33933 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33937 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_features"))) TS_UnsignedNodeAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
33938 LDKUnsignedNodeAnnouncement this_ptr_conv;
33939 this_ptr_conv.inner = untag_ptr(this_ptr);
33940 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33942 this_ptr_conv.is_owned = false;
33943 LDKNodeFeatures val_conv;
33944 val_conv.inner = untag_ptr(val);
33945 val_conv.is_owned = ptr_is_owned(val);
33946 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33947 val_conv = NodeFeatures_clone(&val_conv);
33948 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
33951 int32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_timestamp"))) TS_UnsignedNodeAnnouncement_get_timestamp(uint64_t this_ptr) {
33952 LDKUnsignedNodeAnnouncement this_ptr_conv;
33953 this_ptr_conv.inner = untag_ptr(this_ptr);
33954 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33956 this_ptr_conv.is_owned = false;
33957 int32_t ret_conv = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
33961 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_timestamp"))) TS_UnsignedNodeAnnouncement_set_timestamp(uint64_t this_ptr, int32_t val) {
33962 LDKUnsignedNodeAnnouncement 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 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
33970 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_node_id"))) TS_UnsignedNodeAnnouncement_get_node_id(uint64_t this_ptr) {
33971 LDKUnsignedNodeAnnouncement this_ptr_conv;
33972 this_ptr_conv.inner = untag_ptr(this_ptr);
33973 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33974 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33975 this_ptr_conv.is_owned = false;
33976 LDKNodeId ret_var = UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv);
33977 uint64_t ret_ref = 0;
33978 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33979 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33983 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_node_id"))) TS_UnsignedNodeAnnouncement_set_node_id(uint64_t this_ptr, uint64_t val) {
33984 LDKUnsignedNodeAnnouncement this_ptr_conv;
33985 this_ptr_conv.inner = untag_ptr(this_ptr);
33986 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33988 this_ptr_conv.is_owned = false;
33989 LDKNodeId val_conv;
33990 val_conv.inner = untag_ptr(val);
33991 val_conv.is_owned = ptr_is_owned(val);
33992 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33993 val_conv = NodeId_clone(&val_conv);
33994 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_conv);
33997 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_rgb"))) TS_UnsignedNodeAnnouncement_get_rgb(uint64_t this_ptr) {
33998 LDKUnsignedNodeAnnouncement this_ptr_conv;
33999 this_ptr_conv.inner = untag_ptr(this_ptr);
34000 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34002 this_ptr_conv.is_owned = false;
34003 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
34004 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
34008 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_rgb"))) TS_UnsignedNodeAnnouncement_set_rgb(uint64_t this_ptr, int8_tArray val) {
34009 LDKUnsignedNodeAnnouncement this_ptr_conv;
34010 this_ptr_conv.inner = untag_ptr(this_ptr);
34011 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34013 this_ptr_conv.is_owned = false;
34014 LDKThreeBytes val_ref;
34015 CHECK(val->arr_len == 3);
34016 memcpy(val_ref.data, val->elems, 3); FREE(val);
34017 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
34020 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_alias"))) TS_UnsignedNodeAnnouncement_get_alias(uint64_t this_ptr) {
34021 LDKUnsignedNodeAnnouncement this_ptr_conv;
34022 this_ptr_conv.inner = untag_ptr(this_ptr);
34023 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34025 this_ptr_conv.is_owned = false;
34026 LDKNodeAlias ret_var = UnsignedNodeAnnouncement_get_alias(&this_ptr_conv);
34027 uint64_t ret_ref = 0;
34028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34029 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34033 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_alias"))) TS_UnsignedNodeAnnouncement_set_alias(uint64_t this_ptr, uint64_t val) {
34034 LDKUnsignedNodeAnnouncement this_ptr_conv;
34035 this_ptr_conv.inner = untag_ptr(this_ptr);
34036 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34037 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34038 this_ptr_conv.is_owned = false;
34039 LDKNodeAlias val_conv;
34040 val_conv.inner = untag_ptr(val);
34041 val_conv.is_owned = ptr_is_owned(val);
34042 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34043 val_conv = NodeAlias_clone(&val_conv);
34044 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_conv);
34047 uint64_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_addresses"))) TS_UnsignedNodeAnnouncement_get_addresses(uint64_t this_ptr) {
34048 LDKUnsignedNodeAnnouncement this_ptr_conv;
34049 this_ptr_conv.inner = untag_ptr(this_ptr);
34050 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34052 this_ptr_conv.is_owned = false;
34053 LDKCVec_NetAddressZ ret_var = UnsignedNodeAnnouncement_get_addresses(&this_ptr_conv);
34054 uint64_tArray ret_arr = NULL;
34055 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34056 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34057 for (size_t m = 0; m < ret_var.datalen; m++) {
34058 LDKNetAddress *ret_conv_12_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
34059 *ret_conv_12_copy = ret_var.data[m];
34060 uint64_t ret_conv_12_ref = tag_ptr(ret_conv_12_copy, true);
34061 ret_arr_ptr[m] = ret_conv_12_ref;
34064 FREE(ret_var.data);
34068 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_addresses"))) TS_UnsignedNodeAnnouncement_set_addresses(uint64_t this_ptr, uint64_tArray val) {
34069 LDKUnsignedNodeAnnouncement this_ptr_conv;
34070 this_ptr_conv.inner = untag_ptr(this_ptr);
34071 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34072 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34073 this_ptr_conv.is_owned = false;
34074 LDKCVec_NetAddressZ val_constr;
34075 val_constr.datalen = val->arr_len;
34076 if (val_constr.datalen > 0)
34077 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
34079 val_constr.data = NULL;
34080 uint64_t* val_vals = val->elems;
34081 for (size_t m = 0; m < val_constr.datalen; m++) {
34082 uint64_t val_conv_12 = val_vals[m];
34083 void* val_conv_12_ptr = untag_ptr(val_conv_12);
34084 CHECK_ACCESS(val_conv_12_ptr);
34085 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(val_conv_12_ptr);
34086 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(val_conv_12));
34087 val_constr.data[m] = val_conv_12_conv;
34090 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
34093 static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
34094 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
34095 uint64_t ret_ref = 0;
34096 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34097 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34100 int64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone_ptr"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint64_t arg) {
34101 LDKUnsignedNodeAnnouncement arg_conv;
34102 arg_conv.inner = untag_ptr(arg);
34103 arg_conv.is_owned = ptr_is_owned(arg);
34104 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34105 arg_conv.is_owned = false;
34106 int64_t ret_conv = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
34110 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone"))) TS_UnsignedNodeAnnouncement_clone(uint64_t orig) {
34111 LDKUnsignedNodeAnnouncement orig_conv;
34112 orig_conv.inner = untag_ptr(orig);
34113 orig_conv.is_owned = ptr_is_owned(orig);
34114 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34115 orig_conv.is_owned = false;
34116 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
34117 uint64_t ret_ref = 0;
34118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34119 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34123 jboolean __attribute__((export_name("TS_UnsignedNodeAnnouncement_eq"))) TS_UnsignedNodeAnnouncement_eq(uint64_t a, uint64_t b) {
34124 LDKUnsignedNodeAnnouncement a_conv;
34125 a_conv.inner = untag_ptr(a);
34126 a_conv.is_owned = ptr_is_owned(a);
34127 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34128 a_conv.is_owned = false;
34129 LDKUnsignedNodeAnnouncement b_conv;
34130 b_conv.inner = untag_ptr(b);
34131 b_conv.is_owned = ptr_is_owned(b);
34132 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34133 b_conv.is_owned = false;
34134 jboolean ret_conv = UnsignedNodeAnnouncement_eq(&a_conv, &b_conv);
34138 void __attribute__((export_name("TS_NodeAnnouncement_free"))) TS_NodeAnnouncement_free(uint64_t this_obj) {
34139 LDKNodeAnnouncement this_obj_conv;
34140 this_obj_conv.inner = untag_ptr(this_obj);
34141 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34143 NodeAnnouncement_free(this_obj_conv);
34146 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_get_signature"))) TS_NodeAnnouncement_get_signature(uint64_t this_ptr) {
34147 LDKNodeAnnouncement this_ptr_conv;
34148 this_ptr_conv.inner = untag_ptr(this_ptr);
34149 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34151 this_ptr_conv.is_owned = false;
34152 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34153 memcpy(ret_arr->elems, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
34157 void __attribute__((export_name("TS_NodeAnnouncement_set_signature"))) TS_NodeAnnouncement_set_signature(uint64_t this_ptr, int8_tArray val) {
34158 LDKNodeAnnouncement this_ptr_conv;
34159 this_ptr_conv.inner = untag_ptr(this_ptr);
34160 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34162 this_ptr_conv.is_owned = false;
34163 LDKSignature val_ref;
34164 CHECK(val->arr_len == 64);
34165 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34166 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
34169 uint64_t __attribute__((export_name("TS_NodeAnnouncement_get_contents"))) TS_NodeAnnouncement_get_contents(uint64_t this_ptr) {
34170 LDKNodeAnnouncement this_ptr_conv;
34171 this_ptr_conv.inner = untag_ptr(this_ptr);
34172 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34173 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34174 this_ptr_conv.is_owned = false;
34175 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
34176 uint64_t ret_ref = 0;
34177 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34178 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34182 void __attribute__((export_name("TS_NodeAnnouncement_set_contents"))) TS_NodeAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
34183 LDKNodeAnnouncement this_ptr_conv;
34184 this_ptr_conv.inner = untag_ptr(this_ptr);
34185 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34187 this_ptr_conv.is_owned = false;
34188 LDKUnsignedNodeAnnouncement val_conv;
34189 val_conv.inner = untag_ptr(val);
34190 val_conv.is_owned = ptr_is_owned(val);
34191 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34192 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
34193 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
34196 uint64_t __attribute__((export_name("TS_NodeAnnouncement_new"))) TS_NodeAnnouncement_new(int8_tArray signature_arg, uint64_t contents_arg) {
34197 LDKSignature signature_arg_ref;
34198 CHECK(signature_arg->arr_len == 64);
34199 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
34200 LDKUnsignedNodeAnnouncement contents_arg_conv;
34201 contents_arg_conv.inner = untag_ptr(contents_arg);
34202 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
34203 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
34204 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
34205 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
34206 uint64_t ret_ref = 0;
34207 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34208 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34212 static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
34213 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
34214 uint64_t ret_ref = 0;
34215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34216 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34219 int64_t __attribute__((export_name("TS_NodeAnnouncement_clone_ptr"))) TS_NodeAnnouncement_clone_ptr(uint64_t arg) {
34220 LDKNodeAnnouncement arg_conv;
34221 arg_conv.inner = untag_ptr(arg);
34222 arg_conv.is_owned = ptr_is_owned(arg);
34223 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34224 arg_conv.is_owned = false;
34225 int64_t ret_conv = NodeAnnouncement_clone_ptr(&arg_conv);
34229 uint64_t __attribute__((export_name("TS_NodeAnnouncement_clone"))) TS_NodeAnnouncement_clone(uint64_t orig) {
34230 LDKNodeAnnouncement orig_conv;
34231 orig_conv.inner = untag_ptr(orig);
34232 orig_conv.is_owned = ptr_is_owned(orig);
34233 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34234 orig_conv.is_owned = false;
34235 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
34236 uint64_t ret_ref = 0;
34237 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34238 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34242 jboolean __attribute__((export_name("TS_NodeAnnouncement_eq"))) TS_NodeAnnouncement_eq(uint64_t a, uint64_t b) {
34243 LDKNodeAnnouncement a_conv;
34244 a_conv.inner = untag_ptr(a);
34245 a_conv.is_owned = ptr_is_owned(a);
34246 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34247 a_conv.is_owned = false;
34248 LDKNodeAnnouncement b_conv;
34249 b_conv.inner = untag_ptr(b);
34250 b_conv.is_owned = ptr_is_owned(b);
34251 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34252 b_conv.is_owned = false;
34253 jboolean ret_conv = NodeAnnouncement_eq(&a_conv, &b_conv);
34257 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_free"))) TS_UnsignedChannelAnnouncement_free(uint64_t this_obj) {
34258 LDKUnsignedChannelAnnouncement this_obj_conv;
34259 this_obj_conv.inner = untag_ptr(this_obj);
34260 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34262 UnsignedChannelAnnouncement_free(this_obj_conv);
34265 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_features"))) TS_UnsignedChannelAnnouncement_get_features(uint64_t this_ptr) {
34266 LDKUnsignedChannelAnnouncement this_ptr_conv;
34267 this_ptr_conv.inner = untag_ptr(this_ptr);
34268 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34270 this_ptr_conv.is_owned = false;
34271 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
34272 uint64_t ret_ref = 0;
34273 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34274 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34278 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_features"))) TS_UnsignedChannelAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
34279 LDKUnsignedChannelAnnouncement this_ptr_conv;
34280 this_ptr_conv.inner = untag_ptr(this_ptr);
34281 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34282 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34283 this_ptr_conv.is_owned = false;
34284 LDKChannelFeatures val_conv;
34285 val_conv.inner = untag_ptr(val);
34286 val_conv.is_owned = ptr_is_owned(val);
34287 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34288 val_conv = ChannelFeatures_clone(&val_conv);
34289 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
34292 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_chain_hash"))) TS_UnsignedChannelAnnouncement_get_chain_hash(uint64_t this_ptr) {
34293 LDKUnsignedChannelAnnouncement this_ptr_conv;
34294 this_ptr_conv.inner = untag_ptr(this_ptr);
34295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34297 this_ptr_conv.is_owned = false;
34298 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34299 memcpy(ret_arr->elems, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
34303 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_chain_hash"))) TS_UnsignedChannelAnnouncement_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34304 LDKUnsignedChannelAnnouncement this_ptr_conv;
34305 this_ptr_conv.inner = untag_ptr(this_ptr);
34306 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34308 this_ptr_conv.is_owned = false;
34309 LDKThirtyTwoBytes val_ref;
34310 CHECK(val->arr_len == 32);
34311 memcpy(val_ref.data, val->elems, 32); FREE(val);
34312 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
34315 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_short_channel_id"))) TS_UnsignedChannelAnnouncement_get_short_channel_id(uint64_t this_ptr) {
34316 LDKUnsignedChannelAnnouncement this_ptr_conv;
34317 this_ptr_conv.inner = untag_ptr(this_ptr);
34318 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34319 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34320 this_ptr_conv.is_owned = false;
34321 int64_t ret_conv = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
34325 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_short_channel_id"))) TS_UnsignedChannelAnnouncement_set_short_channel_id(uint64_t this_ptr, int64_t val) {
34326 LDKUnsignedChannelAnnouncement this_ptr_conv;
34327 this_ptr_conv.inner = untag_ptr(this_ptr);
34328 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34329 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34330 this_ptr_conv.is_owned = false;
34331 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
34334 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_1"))) TS_UnsignedChannelAnnouncement_get_node_id_1(uint64_t this_ptr) {
34335 LDKUnsignedChannelAnnouncement this_ptr_conv;
34336 this_ptr_conv.inner = untag_ptr(this_ptr);
34337 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34339 this_ptr_conv.is_owned = false;
34340 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv);
34341 uint64_t ret_ref = 0;
34342 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34343 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34347 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_1"))) TS_UnsignedChannelAnnouncement_set_node_id_1(uint64_t this_ptr, uint64_t val) {
34348 LDKUnsignedChannelAnnouncement this_ptr_conv;
34349 this_ptr_conv.inner = untag_ptr(this_ptr);
34350 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34352 this_ptr_conv.is_owned = false;
34353 LDKNodeId val_conv;
34354 val_conv.inner = untag_ptr(val);
34355 val_conv.is_owned = ptr_is_owned(val);
34356 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34357 val_conv = NodeId_clone(&val_conv);
34358 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_conv);
34361 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_2"))) TS_UnsignedChannelAnnouncement_get_node_id_2(uint64_t this_ptr) {
34362 LDKUnsignedChannelAnnouncement this_ptr_conv;
34363 this_ptr_conv.inner = untag_ptr(this_ptr);
34364 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34366 this_ptr_conv.is_owned = false;
34367 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv);
34368 uint64_t ret_ref = 0;
34369 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34370 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34374 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_2"))) TS_UnsignedChannelAnnouncement_set_node_id_2(uint64_t this_ptr, uint64_t val) {
34375 LDKUnsignedChannelAnnouncement this_ptr_conv;
34376 this_ptr_conv.inner = untag_ptr(this_ptr);
34377 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34379 this_ptr_conv.is_owned = false;
34380 LDKNodeId val_conv;
34381 val_conv.inner = untag_ptr(val);
34382 val_conv.is_owned = ptr_is_owned(val);
34383 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34384 val_conv = NodeId_clone(&val_conv);
34385 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_conv);
34388 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(uint64_t this_ptr) {
34389 LDKUnsignedChannelAnnouncement this_ptr_conv;
34390 this_ptr_conv.inner = untag_ptr(this_ptr);
34391 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34393 this_ptr_conv.is_owned = false;
34394 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv);
34395 uint64_t ret_ref = 0;
34396 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34397 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34401 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(uint64_t this_ptr, uint64_t val) {
34402 LDKUnsignedChannelAnnouncement 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 LDKNodeId val_conv;
34408 val_conv.inner = untag_ptr(val);
34409 val_conv.is_owned = ptr_is_owned(val);
34410 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34411 val_conv = NodeId_clone(&val_conv);
34412 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_conv);
34415 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(uint64_t this_ptr) {
34416 LDKUnsignedChannelAnnouncement this_ptr_conv;
34417 this_ptr_conv.inner = untag_ptr(this_ptr);
34418 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34419 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34420 this_ptr_conv.is_owned = false;
34421 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv);
34422 uint64_t ret_ref = 0;
34423 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34424 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34428 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(uint64_t this_ptr, uint64_t val) {
34429 LDKUnsignedChannelAnnouncement this_ptr_conv;
34430 this_ptr_conv.inner = untag_ptr(this_ptr);
34431 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34433 this_ptr_conv.is_owned = false;
34434 LDKNodeId val_conv;
34435 val_conv.inner = untag_ptr(val);
34436 val_conv.is_owned = ptr_is_owned(val);
34437 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34438 val_conv = NodeId_clone(&val_conv);
34439 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_conv);
34442 static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
34443 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
34444 uint64_t ret_ref = 0;
34445 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34446 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34449 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone_ptr"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint64_t arg) {
34450 LDKUnsignedChannelAnnouncement arg_conv;
34451 arg_conv.inner = untag_ptr(arg);
34452 arg_conv.is_owned = ptr_is_owned(arg);
34453 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34454 arg_conv.is_owned = false;
34455 int64_t ret_conv = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
34459 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone"))) TS_UnsignedChannelAnnouncement_clone(uint64_t orig) {
34460 LDKUnsignedChannelAnnouncement orig_conv;
34461 orig_conv.inner = untag_ptr(orig);
34462 orig_conv.is_owned = ptr_is_owned(orig);
34463 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34464 orig_conv.is_owned = false;
34465 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
34466 uint64_t ret_ref = 0;
34467 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34468 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34472 jboolean __attribute__((export_name("TS_UnsignedChannelAnnouncement_eq"))) TS_UnsignedChannelAnnouncement_eq(uint64_t a, uint64_t b) {
34473 LDKUnsignedChannelAnnouncement a_conv;
34474 a_conv.inner = untag_ptr(a);
34475 a_conv.is_owned = ptr_is_owned(a);
34476 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34477 a_conv.is_owned = false;
34478 LDKUnsignedChannelAnnouncement b_conv;
34479 b_conv.inner = untag_ptr(b);
34480 b_conv.is_owned = ptr_is_owned(b);
34481 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34482 b_conv.is_owned = false;
34483 jboolean ret_conv = UnsignedChannelAnnouncement_eq(&a_conv, &b_conv);
34487 void __attribute__((export_name("TS_ChannelAnnouncement_free"))) TS_ChannelAnnouncement_free(uint64_t this_obj) {
34488 LDKChannelAnnouncement this_obj_conv;
34489 this_obj_conv.inner = untag_ptr(this_obj);
34490 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34492 ChannelAnnouncement_free(this_obj_conv);
34495 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_1"))) TS_ChannelAnnouncement_get_node_signature_1(uint64_t this_ptr) {
34496 LDKChannelAnnouncement this_ptr_conv;
34497 this_ptr_conv.inner = untag_ptr(this_ptr);
34498 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34499 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34500 this_ptr_conv.is_owned = false;
34501 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34502 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
34506 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_1"))) TS_ChannelAnnouncement_set_node_signature_1(uint64_t this_ptr, int8_tArray val) {
34507 LDKChannelAnnouncement this_ptr_conv;
34508 this_ptr_conv.inner = untag_ptr(this_ptr);
34509 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34510 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34511 this_ptr_conv.is_owned = false;
34512 LDKSignature val_ref;
34513 CHECK(val->arr_len == 64);
34514 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34515 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
34518 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_2"))) TS_ChannelAnnouncement_get_node_signature_2(uint64_t this_ptr) {
34519 LDKChannelAnnouncement this_ptr_conv;
34520 this_ptr_conv.inner = untag_ptr(this_ptr);
34521 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34523 this_ptr_conv.is_owned = false;
34524 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34525 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
34529 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_2"))) TS_ChannelAnnouncement_set_node_signature_2(uint64_t this_ptr, int8_tArray val) {
34530 LDKChannelAnnouncement this_ptr_conv;
34531 this_ptr_conv.inner = untag_ptr(this_ptr);
34532 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34533 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34534 this_ptr_conv.is_owned = false;
34535 LDKSignature val_ref;
34536 CHECK(val->arr_len == 64);
34537 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34538 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
34541 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_1"))) TS_ChannelAnnouncement_get_bitcoin_signature_1(uint64_t this_ptr) {
34542 LDKChannelAnnouncement this_ptr_conv;
34543 this_ptr_conv.inner = untag_ptr(this_ptr);
34544 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34545 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34546 this_ptr_conv.is_owned = false;
34547 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34548 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
34552 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_1"))) TS_ChannelAnnouncement_set_bitcoin_signature_1(uint64_t this_ptr, int8_tArray val) {
34553 LDKChannelAnnouncement this_ptr_conv;
34554 this_ptr_conv.inner = untag_ptr(this_ptr);
34555 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34557 this_ptr_conv.is_owned = false;
34558 LDKSignature val_ref;
34559 CHECK(val->arr_len == 64);
34560 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34561 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
34564 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_2"))) TS_ChannelAnnouncement_get_bitcoin_signature_2(uint64_t this_ptr) {
34565 LDKChannelAnnouncement this_ptr_conv;
34566 this_ptr_conv.inner = untag_ptr(this_ptr);
34567 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34569 this_ptr_conv.is_owned = false;
34570 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34571 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
34575 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_2"))) TS_ChannelAnnouncement_set_bitcoin_signature_2(uint64_t this_ptr, int8_tArray val) {
34576 LDKChannelAnnouncement this_ptr_conv;
34577 this_ptr_conv.inner = untag_ptr(this_ptr);
34578 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34580 this_ptr_conv.is_owned = false;
34581 LDKSignature val_ref;
34582 CHECK(val->arr_len == 64);
34583 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34584 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
34587 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_get_contents"))) TS_ChannelAnnouncement_get_contents(uint64_t this_ptr) {
34588 LDKChannelAnnouncement this_ptr_conv;
34589 this_ptr_conv.inner = untag_ptr(this_ptr);
34590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34592 this_ptr_conv.is_owned = false;
34593 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
34594 uint64_t ret_ref = 0;
34595 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34596 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34600 void __attribute__((export_name("TS_ChannelAnnouncement_set_contents"))) TS_ChannelAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
34601 LDKChannelAnnouncement this_ptr_conv;
34602 this_ptr_conv.inner = untag_ptr(this_ptr);
34603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34605 this_ptr_conv.is_owned = false;
34606 LDKUnsignedChannelAnnouncement val_conv;
34607 val_conv.inner = untag_ptr(val);
34608 val_conv.is_owned = ptr_is_owned(val);
34609 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34610 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
34611 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
34614 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) {
34615 LDKSignature node_signature_1_arg_ref;
34616 CHECK(node_signature_1_arg->arr_len == 64);
34617 memcpy(node_signature_1_arg_ref.compact_form, node_signature_1_arg->elems, 64); FREE(node_signature_1_arg);
34618 LDKSignature node_signature_2_arg_ref;
34619 CHECK(node_signature_2_arg->arr_len == 64);
34620 memcpy(node_signature_2_arg_ref.compact_form, node_signature_2_arg->elems, 64); FREE(node_signature_2_arg);
34621 LDKSignature bitcoin_signature_1_arg_ref;
34622 CHECK(bitcoin_signature_1_arg->arr_len == 64);
34623 memcpy(bitcoin_signature_1_arg_ref.compact_form, bitcoin_signature_1_arg->elems, 64); FREE(bitcoin_signature_1_arg);
34624 LDKSignature bitcoin_signature_2_arg_ref;
34625 CHECK(bitcoin_signature_2_arg->arr_len == 64);
34626 memcpy(bitcoin_signature_2_arg_ref.compact_form, bitcoin_signature_2_arg->elems, 64); FREE(bitcoin_signature_2_arg);
34627 LDKUnsignedChannelAnnouncement contents_arg_conv;
34628 contents_arg_conv.inner = untag_ptr(contents_arg);
34629 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
34630 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
34631 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
34632 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);
34633 uint64_t ret_ref = 0;
34634 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34635 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34639 static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
34640 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
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);
34646 int64_t __attribute__((export_name("TS_ChannelAnnouncement_clone_ptr"))) TS_ChannelAnnouncement_clone_ptr(uint64_t arg) {
34647 LDKChannelAnnouncement arg_conv;
34648 arg_conv.inner = untag_ptr(arg);
34649 arg_conv.is_owned = ptr_is_owned(arg);
34650 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34651 arg_conv.is_owned = false;
34652 int64_t ret_conv = ChannelAnnouncement_clone_ptr(&arg_conv);
34656 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_clone"))) TS_ChannelAnnouncement_clone(uint64_t orig) {
34657 LDKChannelAnnouncement orig_conv;
34658 orig_conv.inner = untag_ptr(orig);
34659 orig_conv.is_owned = ptr_is_owned(orig);
34660 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34661 orig_conv.is_owned = false;
34662 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
34663 uint64_t ret_ref = 0;
34664 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34665 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34669 jboolean __attribute__((export_name("TS_ChannelAnnouncement_eq"))) TS_ChannelAnnouncement_eq(uint64_t a, uint64_t b) {
34670 LDKChannelAnnouncement a_conv;
34671 a_conv.inner = untag_ptr(a);
34672 a_conv.is_owned = ptr_is_owned(a);
34673 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34674 a_conv.is_owned = false;
34675 LDKChannelAnnouncement b_conv;
34676 b_conv.inner = untag_ptr(b);
34677 b_conv.is_owned = ptr_is_owned(b);
34678 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34679 b_conv.is_owned = false;
34680 jboolean ret_conv = ChannelAnnouncement_eq(&a_conv, &b_conv);
34684 void __attribute__((export_name("TS_UnsignedChannelUpdate_free"))) TS_UnsignedChannelUpdate_free(uint64_t this_obj) {
34685 LDKUnsignedChannelUpdate this_obj_conv;
34686 this_obj_conv.inner = untag_ptr(this_obj);
34687 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34689 UnsignedChannelUpdate_free(this_obj_conv);
34692 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_chain_hash"))) TS_UnsignedChannelUpdate_get_chain_hash(uint64_t this_ptr) {
34693 LDKUnsignedChannelUpdate this_ptr_conv;
34694 this_ptr_conv.inner = untag_ptr(this_ptr);
34695 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34696 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34697 this_ptr_conv.is_owned = false;
34698 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34699 memcpy(ret_arr->elems, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
34703 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_chain_hash"))) TS_UnsignedChannelUpdate_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34704 LDKUnsignedChannelUpdate this_ptr_conv;
34705 this_ptr_conv.inner = untag_ptr(this_ptr);
34706 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34707 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34708 this_ptr_conv.is_owned = false;
34709 LDKThirtyTwoBytes val_ref;
34710 CHECK(val->arr_len == 32);
34711 memcpy(val_ref.data, val->elems, 32); FREE(val);
34712 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
34715 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_short_channel_id"))) TS_UnsignedChannelUpdate_get_short_channel_id(uint64_t this_ptr) {
34716 LDKUnsignedChannelUpdate this_ptr_conv;
34717 this_ptr_conv.inner = untag_ptr(this_ptr);
34718 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34720 this_ptr_conv.is_owned = false;
34721 int64_t ret_conv = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
34725 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_short_channel_id"))) TS_UnsignedChannelUpdate_set_short_channel_id(uint64_t this_ptr, int64_t val) {
34726 LDKUnsignedChannelUpdate this_ptr_conv;
34727 this_ptr_conv.inner = untag_ptr(this_ptr);
34728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34730 this_ptr_conv.is_owned = false;
34731 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
34734 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_timestamp"))) TS_UnsignedChannelUpdate_get_timestamp(uint64_t this_ptr) {
34735 LDKUnsignedChannelUpdate this_ptr_conv;
34736 this_ptr_conv.inner = untag_ptr(this_ptr);
34737 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34739 this_ptr_conv.is_owned = false;
34740 int32_t ret_conv = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
34744 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_timestamp"))) TS_UnsignedChannelUpdate_set_timestamp(uint64_t this_ptr, int32_t val) {
34745 LDKUnsignedChannelUpdate this_ptr_conv;
34746 this_ptr_conv.inner = untag_ptr(this_ptr);
34747 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34748 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34749 this_ptr_conv.is_owned = false;
34750 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
34753 int8_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_flags"))) TS_UnsignedChannelUpdate_get_flags(uint64_t this_ptr) {
34754 LDKUnsignedChannelUpdate this_ptr_conv;
34755 this_ptr_conv.inner = untag_ptr(this_ptr);
34756 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34757 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34758 this_ptr_conv.is_owned = false;
34759 int8_t ret_conv = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
34763 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_flags"))) TS_UnsignedChannelUpdate_set_flags(uint64_t this_ptr, int8_t val) {
34764 LDKUnsignedChannelUpdate this_ptr_conv;
34765 this_ptr_conv.inner = untag_ptr(this_ptr);
34766 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34767 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34768 this_ptr_conv.is_owned = false;
34769 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
34772 int16_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_get_cltv_expiry_delta(uint64_t this_ptr) {
34773 LDKUnsignedChannelUpdate this_ptr_conv;
34774 this_ptr_conv.inner = untag_ptr(this_ptr);
34775 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34776 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34777 this_ptr_conv.is_owned = false;
34778 int16_t ret_conv = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
34782 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
34783 LDKUnsignedChannelUpdate this_ptr_conv;
34784 this_ptr_conv.inner = untag_ptr(this_ptr);
34785 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34787 this_ptr_conv.is_owned = false;
34788 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
34791 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_get_htlc_minimum_msat(uint64_t this_ptr) {
34792 LDKUnsignedChannelUpdate this_ptr_conv;
34793 this_ptr_conv.inner = untag_ptr(this_ptr);
34794 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34795 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34796 this_ptr_conv.is_owned = false;
34797 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
34801 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
34802 LDKUnsignedChannelUpdate this_ptr_conv;
34803 this_ptr_conv.inner = untag_ptr(this_ptr);
34804 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34806 this_ptr_conv.is_owned = false;
34807 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
34810 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_get_htlc_maximum_msat(uint64_t this_ptr) {
34811 LDKUnsignedChannelUpdate this_ptr_conv;
34812 this_ptr_conv.inner = untag_ptr(this_ptr);
34813 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34815 this_ptr_conv.is_owned = false;
34816 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_maximum_msat(&this_ptr_conv);
34820 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
34821 LDKUnsignedChannelUpdate 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 UnsignedChannelUpdate_set_htlc_maximum_msat(&this_ptr_conv, val);
34829 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_base_msat"))) TS_UnsignedChannelUpdate_get_fee_base_msat(uint64_t this_ptr) {
34830 LDKUnsignedChannelUpdate this_ptr_conv;
34831 this_ptr_conv.inner = untag_ptr(this_ptr);
34832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34834 this_ptr_conv.is_owned = false;
34835 int32_t ret_conv = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
34839 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_base_msat"))) TS_UnsignedChannelUpdate_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
34840 LDKUnsignedChannelUpdate this_ptr_conv;
34841 this_ptr_conv.inner = untag_ptr(this_ptr);
34842 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34844 this_ptr_conv.is_owned = false;
34845 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
34848 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_get_fee_proportional_millionths(uint64_t this_ptr) {
34849 LDKUnsignedChannelUpdate this_ptr_conv;
34850 this_ptr_conv.inner = untag_ptr(this_ptr);
34851 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34852 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34853 this_ptr_conv.is_owned = false;
34854 int32_t ret_conv = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
34858 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
34859 LDKUnsignedChannelUpdate this_ptr_conv;
34860 this_ptr_conv.inner = untag_ptr(this_ptr);
34861 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34862 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34863 this_ptr_conv.is_owned = false;
34864 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
34867 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_excess_data"))) TS_UnsignedChannelUpdate_get_excess_data(uint64_t this_ptr) {
34868 LDKUnsignedChannelUpdate this_ptr_conv;
34869 this_ptr_conv.inner = untag_ptr(this_ptr);
34870 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34872 this_ptr_conv.is_owned = false;
34873 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_get_excess_data(&this_ptr_conv);
34874 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34875 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34876 CVec_u8Z_free(ret_var);
34880 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_excess_data"))) TS_UnsignedChannelUpdate_set_excess_data(uint64_t this_ptr, int8_tArray val) {
34881 LDKUnsignedChannelUpdate this_ptr_conv;
34882 this_ptr_conv.inner = untag_ptr(this_ptr);
34883 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34885 this_ptr_conv.is_owned = false;
34886 LDKCVec_u8Z val_ref;
34887 val_ref.datalen = val->arr_len;
34888 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
34889 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
34890 UnsignedChannelUpdate_set_excess_data(&this_ptr_conv, val_ref);
34893 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) {
34894 LDKThirtyTwoBytes chain_hash_arg_ref;
34895 CHECK(chain_hash_arg->arr_len == 32);
34896 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34897 LDKCVec_u8Z excess_data_arg_ref;
34898 excess_data_arg_ref.datalen = excess_data_arg->arr_len;
34899 excess_data_arg_ref.data = MALLOC(excess_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
34900 memcpy(excess_data_arg_ref.data, excess_data_arg->elems, excess_data_arg_ref.datalen); FREE(excess_data_arg);
34901 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);
34902 uint64_t ret_ref = 0;
34903 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34904 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34908 static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
34909 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
34910 uint64_t ret_ref = 0;
34911 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34912 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34915 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone_ptr"))) TS_UnsignedChannelUpdate_clone_ptr(uint64_t arg) {
34916 LDKUnsignedChannelUpdate arg_conv;
34917 arg_conv.inner = untag_ptr(arg);
34918 arg_conv.is_owned = ptr_is_owned(arg);
34919 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34920 arg_conv.is_owned = false;
34921 int64_t ret_conv = UnsignedChannelUpdate_clone_ptr(&arg_conv);
34925 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone"))) TS_UnsignedChannelUpdate_clone(uint64_t orig) {
34926 LDKUnsignedChannelUpdate orig_conv;
34927 orig_conv.inner = untag_ptr(orig);
34928 orig_conv.is_owned = ptr_is_owned(orig);
34929 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34930 orig_conv.is_owned = false;
34931 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
34932 uint64_t ret_ref = 0;
34933 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34934 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34938 jboolean __attribute__((export_name("TS_UnsignedChannelUpdate_eq"))) TS_UnsignedChannelUpdate_eq(uint64_t a, uint64_t b) {
34939 LDKUnsignedChannelUpdate a_conv;
34940 a_conv.inner = untag_ptr(a);
34941 a_conv.is_owned = ptr_is_owned(a);
34942 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34943 a_conv.is_owned = false;
34944 LDKUnsignedChannelUpdate b_conv;
34945 b_conv.inner = untag_ptr(b);
34946 b_conv.is_owned = ptr_is_owned(b);
34947 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34948 b_conv.is_owned = false;
34949 jboolean ret_conv = UnsignedChannelUpdate_eq(&a_conv, &b_conv);
34953 void __attribute__((export_name("TS_ChannelUpdate_free"))) TS_ChannelUpdate_free(uint64_t this_obj) {
34954 LDKChannelUpdate this_obj_conv;
34955 this_obj_conv.inner = untag_ptr(this_obj);
34956 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34958 ChannelUpdate_free(this_obj_conv);
34961 int8_tArray __attribute__((export_name("TS_ChannelUpdate_get_signature"))) TS_ChannelUpdate_get_signature(uint64_t this_ptr) {
34962 LDKChannelUpdate this_ptr_conv;
34963 this_ptr_conv.inner = untag_ptr(this_ptr);
34964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34966 this_ptr_conv.is_owned = false;
34967 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34968 memcpy(ret_arr->elems, ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
34972 void __attribute__((export_name("TS_ChannelUpdate_set_signature"))) TS_ChannelUpdate_set_signature(uint64_t this_ptr, int8_tArray val) {
34973 LDKChannelUpdate this_ptr_conv;
34974 this_ptr_conv.inner = untag_ptr(this_ptr);
34975 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34977 this_ptr_conv.is_owned = false;
34978 LDKSignature val_ref;
34979 CHECK(val->arr_len == 64);
34980 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34981 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
34984 uint64_t __attribute__((export_name("TS_ChannelUpdate_get_contents"))) TS_ChannelUpdate_get_contents(uint64_t this_ptr) {
34985 LDKChannelUpdate this_ptr_conv;
34986 this_ptr_conv.inner = untag_ptr(this_ptr);
34987 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34988 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34989 this_ptr_conv.is_owned = false;
34990 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
34991 uint64_t ret_ref = 0;
34992 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34993 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34997 void __attribute__((export_name("TS_ChannelUpdate_set_contents"))) TS_ChannelUpdate_set_contents(uint64_t this_ptr, uint64_t val) {
34998 LDKChannelUpdate this_ptr_conv;
34999 this_ptr_conv.inner = untag_ptr(this_ptr);
35000 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35002 this_ptr_conv.is_owned = false;
35003 LDKUnsignedChannelUpdate val_conv;
35004 val_conv.inner = untag_ptr(val);
35005 val_conv.is_owned = ptr_is_owned(val);
35006 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
35007 val_conv = UnsignedChannelUpdate_clone(&val_conv);
35008 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
35011 uint64_t __attribute__((export_name("TS_ChannelUpdate_new"))) TS_ChannelUpdate_new(int8_tArray signature_arg, uint64_t contents_arg) {
35012 LDKSignature signature_arg_ref;
35013 CHECK(signature_arg->arr_len == 64);
35014 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
35015 LDKUnsignedChannelUpdate contents_arg_conv;
35016 contents_arg_conv.inner = untag_ptr(contents_arg);
35017 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
35018 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
35019 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
35020 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
35021 uint64_t ret_ref = 0;
35022 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35023 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35027 static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
35028 LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
35029 uint64_t ret_ref = 0;
35030 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35031 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35034 int64_t __attribute__((export_name("TS_ChannelUpdate_clone_ptr"))) TS_ChannelUpdate_clone_ptr(uint64_t arg) {
35035 LDKChannelUpdate arg_conv;
35036 arg_conv.inner = untag_ptr(arg);
35037 arg_conv.is_owned = ptr_is_owned(arg);
35038 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35039 arg_conv.is_owned = false;
35040 int64_t ret_conv = ChannelUpdate_clone_ptr(&arg_conv);
35044 uint64_t __attribute__((export_name("TS_ChannelUpdate_clone"))) TS_ChannelUpdate_clone(uint64_t orig) {
35045 LDKChannelUpdate orig_conv;
35046 orig_conv.inner = untag_ptr(orig);
35047 orig_conv.is_owned = ptr_is_owned(orig);
35048 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35049 orig_conv.is_owned = false;
35050 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
35051 uint64_t ret_ref = 0;
35052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35053 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35057 jboolean __attribute__((export_name("TS_ChannelUpdate_eq"))) TS_ChannelUpdate_eq(uint64_t a, uint64_t b) {
35058 LDKChannelUpdate a_conv;
35059 a_conv.inner = untag_ptr(a);
35060 a_conv.is_owned = ptr_is_owned(a);
35061 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35062 a_conv.is_owned = false;
35063 LDKChannelUpdate b_conv;
35064 b_conv.inner = untag_ptr(b);
35065 b_conv.is_owned = ptr_is_owned(b);
35066 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35067 b_conv.is_owned = false;
35068 jboolean ret_conv = ChannelUpdate_eq(&a_conv, &b_conv);
35072 void __attribute__((export_name("TS_QueryChannelRange_free"))) TS_QueryChannelRange_free(uint64_t this_obj) {
35073 LDKQueryChannelRange this_obj_conv;
35074 this_obj_conv.inner = untag_ptr(this_obj);
35075 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35077 QueryChannelRange_free(this_obj_conv);
35080 int8_tArray __attribute__((export_name("TS_QueryChannelRange_get_chain_hash"))) TS_QueryChannelRange_get_chain_hash(uint64_t this_ptr) {
35081 LDKQueryChannelRange this_ptr_conv;
35082 this_ptr_conv.inner = untag_ptr(this_ptr);
35083 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35085 this_ptr_conv.is_owned = false;
35086 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35087 memcpy(ret_arr->elems, *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
35091 void __attribute__((export_name("TS_QueryChannelRange_set_chain_hash"))) TS_QueryChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35092 LDKQueryChannelRange this_ptr_conv;
35093 this_ptr_conv.inner = untag_ptr(this_ptr);
35094 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35096 this_ptr_conv.is_owned = false;
35097 LDKThirtyTwoBytes val_ref;
35098 CHECK(val->arr_len == 32);
35099 memcpy(val_ref.data, val->elems, 32); FREE(val);
35100 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
35103 int32_t __attribute__((export_name("TS_QueryChannelRange_get_first_blocknum"))) TS_QueryChannelRange_get_first_blocknum(uint64_t this_ptr) {
35104 LDKQueryChannelRange this_ptr_conv;
35105 this_ptr_conv.inner = untag_ptr(this_ptr);
35106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35108 this_ptr_conv.is_owned = false;
35109 int32_t ret_conv = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
35113 void __attribute__((export_name("TS_QueryChannelRange_set_first_blocknum"))) TS_QueryChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
35114 LDKQueryChannelRange this_ptr_conv;
35115 this_ptr_conv.inner = untag_ptr(this_ptr);
35116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35118 this_ptr_conv.is_owned = false;
35119 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
35122 int32_t __attribute__((export_name("TS_QueryChannelRange_get_number_of_blocks"))) TS_QueryChannelRange_get_number_of_blocks(uint64_t this_ptr) {
35123 LDKQueryChannelRange this_ptr_conv;
35124 this_ptr_conv.inner = untag_ptr(this_ptr);
35125 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35127 this_ptr_conv.is_owned = false;
35128 int32_t ret_conv = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
35132 void __attribute__((export_name("TS_QueryChannelRange_set_number_of_blocks"))) TS_QueryChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
35133 LDKQueryChannelRange this_ptr_conv;
35134 this_ptr_conv.inner = untag_ptr(this_ptr);
35135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35137 this_ptr_conv.is_owned = false;
35138 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
35141 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) {
35142 LDKThirtyTwoBytes chain_hash_arg_ref;
35143 CHECK(chain_hash_arg->arr_len == 32);
35144 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35145 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
35146 uint64_t ret_ref = 0;
35147 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35148 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35152 static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
35153 LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
35154 uint64_t ret_ref = 0;
35155 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35156 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35159 int64_t __attribute__((export_name("TS_QueryChannelRange_clone_ptr"))) TS_QueryChannelRange_clone_ptr(uint64_t arg) {
35160 LDKQueryChannelRange arg_conv;
35161 arg_conv.inner = untag_ptr(arg);
35162 arg_conv.is_owned = ptr_is_owned(arg);
35163 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35164 arg_conv.is_owned = false;
35165 int64_t ret_conv = QueryChannelRange_clone_ptr(&arg_conv);
35169 uint64_t __attribute__((export_name("TS_QueryChannelRange_clone"))) TS_QueryChannelRange_clone(uint64_t orig) {
35170 LDKQueryChannelRange orig_conv;
35171 orig_conv.inner = untag_ptr(orig);
35172 orig_conv.is_owned = ptr_is_owned(orig);
35173 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35174 orig_conv.is_owned = false;
35175 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
35176 uint64_t ret_ref = 0;
35177 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35178 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35182 jboolean __attribute__((export_name("TS_QueryChannelRange_eq"))) TS_QueryChannelRange_eq(uint64_t a, uint64_t b) {
35183 LDKQueryChannelRange a_conv;
35184 a_conv.inner = untag_ptr(a);
35185 a_conv.is_owned = ptr_is_owned(a);
35186 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35187 a_conv.is_owned = false;
35188 LDKQueryChannelRange b_conv;
35189 b_conv.inner = untag_ptr(b);
35190 b_conv.is_owned = ptr_is_owned(b);
35191 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35192 b_conv.is_owned = false;
35193 jboolean ret_conv = QueryChannelRange_eq(&a_conv, &b_conv);
35197 void __attribute__((export_name("TS_ReplyChannelRange_free"))) TS_ReplyChannelRange_free(uint64_t this_obj) {
35198 LDKReplyChannelRange this_obj_conv;
35199 this_obj_conv.inner = untag_ptr(this_obj);
35200 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35201 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35202 ReplyChannelRange_free(this_obj_conv);
35205 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_get_chain_hash"))) TS_ReplyChannelRange_get_chain_hash(uint64_t this_ptr) {
35206 LDKReplyChannelRange this_ptr_conv;
35207 this_ptr_conv.inner = untag_ptr(this_ptr);
35208 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35210 this_ptr_conv.is_owned = false;
35211 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35212 memcpy(ret_arr->elems, *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
35216 void __attribute__((export_name("TS_ReplyChannelRange_set_chain_hash"))) TS_ReplyChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35217 LDKReplyChannelRange this_ptr_conv;
35218 this_ptr_conv.inner = untag_ptr(this_ptr);
35219 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35221 this_ptr_conv.is_owned = false;
35222 LDKThirtyTwoBytes val_ref;
35223 CHECK(val->arr_len == 32);
35224 memcpy(val_ref.data, val->elems, 32); FREE(val);
35225 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
35228 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_first_blocknum"))) TS_ReplyChannelRange_get_first_blocknum(uint64_t this_ptr) {
35229 LDKReplyChannelRange this_ptr_conv;
35230 this_ptr_conv.inner = untag_ptr(this_ptr);
35231 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35233 this_ptr_conv.is_owned = false;
35234 int32_t ret_conv = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
35238 void __attribute__((export_name("TS_ReplyChannelRange_set_first_blocknum"))) TS_ReplyChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
35239 LDKReplyChannelRange this_ptr_conv;
35240 this_ptr_conv.inner = untag_ptr(this_ptr);
35241 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35243 this_ptr_conv.is_owned = false;
35244 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
35247 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_number_of_blocks"))) TS_ReplyChannelRange_get_number_of_blocks(uint64_t this_ptr) {
35248 LDKReplyChannelRange this_ptr_conv;
35249 this_ptr_conv.inner = untag_ptr(this_ptr);
35250 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35252 this_ptr_conv.is_owned = false;
35253 int32_t ret_conv = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
35257 void __attribute__((export_name("TS_ReplyChannelRange_set_number_of_blocks"))) TS_ReplyChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
35258 LDKReplyChannelRange this_ptr_conv;
35259 this_ptr_conv.inner = untag_ptr(this_ptr);
35260 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35262 this_ptr_conv.is_owned = false;
35263 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
35266 jboolean __attribute__((export_name("TS_ReplyChannelRange_get_sync_complete"))) TS_ReplyChannelRange_get_sync_complete(uint64_t this_ptr) {
35267 LDKReplyChannelRange this_ptr_conv;
35268 this_ptr_conv.inner = untag_ptr(this_ptr);
35269 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35271 this_ptr_conv.is_owned = false;
35272 jboolean ret_conv = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
35276 void __attribute__((export_name("TS_ReplyChannelRange_set_sync_complete"))) TS_ReplyChannelRange_set_sync_complete(uint64_t this_ptr, jboolean val) {
35277 LDKReplyChannelRange this_ptr_conv;
35278 this_ptr_conv.inner = untag_ptr(this_ptr);
35279 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35280 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35281 this_ptr_conv.is_owned = false;
35282 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
35285 int64_tArray __attribute__((export_name("TS_ReplyChannelRange_get_short_channel_ids"))) TS_ReplyChannelRange_get_short_channel_ids(uint64_t this_ptr) {
35286 LDKReplyChannelRange this_ptr_conv;
35287 this_ptr_conv.inner = untag_ptr(this_ptr);
35288 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35290 this_ptr_conv.is_owned = false;
35291 LDKCVec_u64Z ret_var = ReplyChannelRange_get_short_channel_ids(&this_ptr_conv);
35292 int64_tArray ret_arr = NULL;
35293 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
35294 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
35295 for (size_t i = 0; i < ret_var.datalen; i++) {
35296 int64_t ret_conv_8_conv = ret_var.data[i];
35297 ret_arr_ptr[i] = ret_conv_8_conv;
35300 FREE(ret_var.data);
35304 void __attribute__((export_name("TS_ReplyChannelRange_set_short_channel_ids"))) TS_ReplyChannelRange_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
35305 LDKReplyChannelRange this_ptr_conv;
35306 this_ptr_conv.inner = untag_ptr(this_ptr);
35307 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35309 this_ptr_conv.is_owned = false;
35310 LDKCVec_u64Z val_constr;
35311 val_constr.datalen = val->arr_len;
35312 if (val_constr.datalen > 0)
35313 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35315 val_constr.data = NULL;
35316 int64_t* val_vals = val->elems;
35317 for (size_t i = 0; i < val_constr.datalen; i++) {
35318 int64_t val_conv_8 = val_vals[i];
35319 val_constr.data[i] = val_conv_8;
35322 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
35325 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) {
35326 LDKThirtyTwoBytes chain_hash_arg_ref;
35327 CHECK(chain_hash_arg->arr_len == 32);
35328 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35329 LDKCVec_u64Z short_channel_ids_arg_constr;
35330 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
35331 if (short_channel_ids_arg_constr.datalen > 0)
35332 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35334 short_channel_ids_arg_constr.data = NULL;
35335 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
35336 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
35337 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
35338 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
35340 FREE(short_channel_ids_arg);
35341 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
35342 uint64_t ret_ref = 0;
35343 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35344 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35348 static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
35349 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
35350 uint64_t ret_ref = 0;
35351 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35352 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35355 int64_t __attribute__((export_name("TS_ReplyChannelRange_clone_ptr"))) TS_ReplyChannelRange_clone_ptr(uint64_t arg) {
35356 LDKReplyChannelRange arg_conv;
35357 arg_conv.inner = untag_ptr(arg);
35358 arg_conv.is_owned = ptr_is_owned(arg);
35359 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35360 arg_conv.is_owned = false;
35361 int64_t ret_conv = ReplyChannelRange_clone_ptr(&arg_conv);
35365 uint64_t __attribute__((export_name("TS_ReplyChannelRange_clone"))) TS_ReplyChannelRange_clone(uint64_t orig) {
35366 LDKReplyChannelRange orig_conv;
35367 orig_conv.inner = untag_ptr(orig);
35368 orig_conv.is_owned = ptr_is_owned(orig);
35369 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35370 orig_conv.is_owned = false;
35371 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
35372 uint64_t ret_ref = 0;
35373 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35374 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35378 jboolean __attribute__((export_name("TS_ReplyChannelRange_eq"))) TS_ReplyChannelRange_eq(uint64_t a, uint64_t b) {
35379 LDKReplyChannelRange a_conv;
35380 a_conv.inner = untag_ptr(a);
35381 a_conv.is_owned = ptr_is_owned(a);
35382 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35383 a_conv.is_owned = false;
35384 LDKReplyChannelRange b_conv;
35385 b_conv.inner = untag_ptr(b);
35386 b_conv.is_owned = ptr_is_owned(b);
35387 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35388 b_conv.is_owned = false;
35389 jboolean ret_conv = ReplyChannelRange_eq(&a_conv, &b_conv);
35393 void __attribute__((export_name("TS_QueryShortChannelIds_free"))) TS_QueryShortChannelIds_free(uint64_t this_obj) {
35394 LDKQueryShortChannelIds this_obj_conv;
35395 this_obj_conv.inner = untag_ptr(this_obj);
35396 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35398 QueryShortChannelIds_free(this_obj_conv);
35401 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_chain_hash"))) TS_QueryShortChannelIds_get_chain_hash(uint64_t this_ptr) {
35402 LDKQueryShortChannelIds this_ptr_conv;
35403 this_ptr_conv.inner = untag_ptr(this_ptr);
35404 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35406 this_ptr_conv.is_owned = false;
35407 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35408 memcpy(ret_arr->elems, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
35412 void __attribute__((export_name("TS_QueryShortChannelIds_set_chain_hash"))) TS_QueryShortChannelIds_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35413 LDKQueryShortChannelIds this_ptr_conv;
35414 this_ptr_conv.inner = untag_ptr(this_ptr);
35415 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35417 this_ptr_conv.is_owned = false;
35418 LDKThirtyTwoBytes val_ref;
35419 CHECK(val->arr_len == 32);
35420 memcpy(val_ref.data, val->elems, 32); FREE(val);
35421 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
35424 int64_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_short_channel_ids"))) TS_QueryShortChannelIds_get_short_channel_ids(uint64_t this_ptr) {
35425 LDKQueryShortChannelIds this_ptr_conv;
35426 this_ptr_conv.inner = untag_ptr(this_ptr);
35427 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35429 this_ptr_conv.is_owned = false;
35430 LDKCVec_u64Z ret_var = QueryShortChannelIds_get_short_channel_ids(&this_ptr_conv);
35431 int64_tArray ret_arr = NULL;
35432 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
35433 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
35434 for (size_t i = 0; i < ret_var.datalen; i++) {
35435 int64_t ret_conv_8_conv = ret_var.data[i];
35436 ret_arr_ptr[i] = ret_conv_8_conv;
35439 FREE(ret_var.data);
35443 void __attribute__((export_name("TS_QueryShortChannelIds_set_short_channel_ids"))) TS_QueryShortChannelIds_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
35444 LDKQueryShortChannelIds this_ptr_conv;
35445 this_ptr_conv.inner = untag_ptr(this_ptr);
35446 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35447 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35448 this_ptr_conv.is_owned = false;
35449 LDKCVec_u64Z val_constr;
35450 val_constr.datalen = val->arr_len;
35451 if (val_constr.datalen > 0)
35452 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35454 val_constr.data = NULL;
35455 int64_t* val_vals = val->elems;
35456 for (size_t i = 0; i < val_constr.datalen; i++) {
35457 int64_t val_conv_8 = val_vals[i];
35458 val_constr.data[i] = val_conv_8;
35461 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
35464 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_new"))) TS_QueryShortChannelIds_new(int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
35465 LDKThirtyTwoBytes chain_hash_arg_ref;
35466 CHECK(chain_hash_arg->arr_len == 32);
35467 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35468 LDKCVec_u64Z short_channel_ids_arg_constr;
35469 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
35470 if (short_channel_ids_arg_constr.datalen > 0)
35471 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35473 short_channel_ids_arg_constr.data = NULL;
35474 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
35475 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
35476 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
35477 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
35479 FREE(short_channel_ids_arg);
35480 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
35481 uint64_t ret_ref = 0;
35482 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35483 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35487 static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
35488 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
35489 uint64_t ret_ref = 0;
35490 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35491 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35494 int64_t __attribute__((export_name("TS_QueryShortChannelIds_clone_ptr"))) TS_QueryShortChannelIds_clone_ptr(uint64_t arg) {
35495 LDKQueryShortChannelIds arg_conv;
35496 arg_conv.inner = untag_ptr(arg);
35497 arg_conv.is_owned = ptr_is_owned(arg);
35498 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35499 arg_conv.is_owned = false;
35500 int64_t ret_conv = QueryShortChannelIds_clone_ptr(&arg_conv);
35504 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_clone"))) TS_QueryShortChannelIds_clone(uint64_t orig) {
35505 LDKQueryShortChannelIds orig_conv;
35506 orig_conv.inner = untag_ptr(orig);
35507 orig_conv.is_owned = ptr_is_owned(orig);
35508 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35509 orig_conv.is_owned = false;
35510 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
35511 uint64_t ret_ref = 0;
35512 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35513 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35517 jboolean __attribute__((export_name("TS_QueryShortChannelIds_eq"))) TS_QueryShortChannelIds_eq(uint64_t a, uint64_t b) {
35518 LDKQueryShortChannelIds a_conv;
35519 a_conv.inner = untag_ptr(a);
35520 a_conv.is_owned = ptr_is_owned(a);
35521 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35522 a_conv.is_owned = false;
35523 LDKQueryShortChannelIds b_conv;
35524 b_conv.inner = untag_ptr(b);
35525 b_conv.is_owned = ptr_is_owned(b);
35526 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35527 b_conv.is_owned = false;
35528 jboolean ret_conv = QueryShortChannelIds_eq(&a_conv, &b_conv);
35532 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_free"))) TS_ReplyShortChannelIdsEnd_free(uint64_t this_obj) {
35533 LDKReplyShortChannelIdsEnd this_obj_conv;
35534 this_obj_conv.inner = untag_ptr(this_obj);
35535 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35537 ReplyShortChannelIdsEnd_free(this_obj_conv);
35540 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_chain_hash"))) TS_ReplyShortChannelIdsEnd_get_chain_hash(uint64_t this_ptr) {
35541 LDKReplyShortChannelIdsEnd this_ptr_conv;
35542 this_ptr_conv.inner = untag_ptr(this_ptr);
35543 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35545 this_ptr_conv.is_owned = false;
35546 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35547 memcpy(ret_arr->elems, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
35551 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_chain_hash"))) TS_ReplyShortChannelIdsEnd_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35552 LDKReplyShortChannelIdsEnd this_ptr_conv;
35553 this_ptr_conv.inner = untag_ptr(this_ptr);
35554 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35556 this_ptr_conv.is_owned = false;
35557 LDKThirtyTwoBytes val_ref;
35558 CHECK(val->arr_len == 32);
35559 memcpy(val_ref.data, val->elems, 32); FREE(val);
35560 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
35563 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_full_information"))) TS_ReplyShortChannelIdsEnd_get_full_information(uint64_t this_ptr) {
35564 LDKReplyShortChannelIdsEnd this_ptr_conv;
35565 this_ptr_conv.inner = untag_ptr(this_ptr);
35566 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35568 this_ptr_conv.is_owned = false;
35569 jboolean ret_conv = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
35573 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_full_information"))) TS_ReplyShortChannelIdsEnd_set_full_information(uint64_t this_ptr, jboolean val) {
35574 LDKReplyShortChannelIdsEnd this_ptr_conv;
35575 this_ptr_conv.inner = untag_ptr(this_ptr);
35576 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35577 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35578 this_ptr_conv.is_owned = false;
35579 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
35582 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_new"))) TS_ReplyShortChannelIdsEnd_new(int8_tArray chain_hash_arg, jboolean full_information_arg) {
35583 LDKThirtyTwoBytes chain_hash_arg_ref;
35584 CHECK(chain_hash_arg->arr_len == 32);
35585 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35586 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
35587 uint64_t ret_ref = 0;
35588 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35589 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35593 static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
35594 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
35595 uint64_t ret_ref = 0;
35596 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35597 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35600 int64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone_ptr"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint64_t arg) {
35601 LDKReplyShortChannelIdsEnd arg_conv;
35602 arg_conv.inner = untag_ptr(arg);
35603 arg_conv.is_owned = ptr_is_owned(arg);
35604 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35605 arg_conv.is_owned = false;
35606 int64_t ret_conv = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
35610 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone"))) TS_ReplyShortChannelIdsEnd_clone(uint64_t orig) {
35611 LDKReplyShortChannelIdsEnd orig_conv;
35612 orig_conv.inner = untag_ptr(orig);
35613 orig_conv.is_owned = ptr_is_owned(orig);
35614 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35615 orig_conv.is_owned = false;
35616 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
35617 uint64_t ret_ref = 0;
35618 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35619 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35623 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_eq"))) TS_ReplyShortChannelIdsEnd_eq(uint64_t a, uint64_t b) {
35624 LDKReplyShortChannelIdsEnd a_conv;
35625 a_conv.inner = untag_ptr(a);
35626 a_conv.is_owned = ptr_is_owned(a);
35627 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35628 a_conv.is_owned = false;
35629 LDKReplyShortChannelIdsEnd b_conv;
35630 b_conv.inner = untag_ptr(b);
35631 b_conv.is_owned = ptr_is_owned(b);
35632 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35633 b_conv.is_owned = false;
35634 jboolean ret_conv = ReplyShortChannelIdsEnd_eq(&a_conv, &b_conv);
35638 void __attribute__((export_name("TS_GossipTimestampFilter_free"))) TS_GossipTimestampFilter_free(uint64_t this_obj) {
35639 LDKGossipTimestampFilter this_obj_conv;
35640 this_obj_conv.inner = untag_ptr(this_obj);
35641 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35643 GossipTimestampFilter_free(this_obj_conv);
35646 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_get_chain_hash"))) TS_GossipTimestampFilter_get_chain_hash(uint64_t this_ptr) {
35647 LDKGossipTimestampFilter this_ptr_conv;
35648 this_ptr_conv.inner = untag_ptr(this_ptr);
35649 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35650 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35651 this_ptr_conv.is_owned = false;
35652 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35653 memcpy(ret_arr->elems, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
35657 void __attribute__((export_name("TS_GossipTimestampFilter_set_chain_hash"))) TS_GossipTimestampFilter_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35658 LDKGossipTimestampFilter this_ptr_conv;
35659 this_ptr_conv.inner = untag_ptr(this_ptr);
35660 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35661 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35662 this_ptr_conv.is_owned = false;
35663 LDKThirtyTwoBytes val_ref;
35664 CHECK(val->arr_len == 32);
35665 memcpy(val_ref.data, val->elems, 32); FREE(val);
35666 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
35669 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_first_timestamp"))) TS_GossipTimestampFilter_get_first_timestamp(uint64_t this_ptr) {
35670 LDKGossipTimestampFilter this_ptr_conv;
35671 this_ptr_conv.inner = untag_ptr(this_ptr);
35672 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35674 this_ptr_conv.is_owned = false;
35675 int32_t ret_conv = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
35679 void __attribute__((export_name("TS_GossipTimestampFilter_set_first_timestamp"))) TS_GossipTimestampFilter_set_first_timestamp(uint64_t this_ptr, int32_t val) {
35680 LDKGossipTimestampFilter this_ptr_conv;
35681 this_ptr_conv.inner = untag_ptr(this_ptr);
35682 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35683 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35684 this_ptr_conv.is_owned = false;
35685 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
35688 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_timestamp_range"))) TS_GossipTimestampFilter_get_timestamp_range(uint64_t this_ptr) {
35689 LDKGossipTimestampFilter this_ptr_conv;
35690 this_ptr_conv.inner = untag_ptr(this_ptr);
35691 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35693 this_ptr_conv.is_owned = false;
35694 int32_t ret_conv = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
35698 void __attribute__((export_name("TS_GossipTimestampFilter_set_timestamp_range"))) TS_GossipTimestampFilter_set_timestamp_range(uint64_t this_ptr, int32_t val) {
35699 LDKGossipTimestampFilter this_ptr_conv;
35700 this_ptr_conv.inner = untag_ptr(this_ptr);
35701 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35702 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35703 this_ptr_conv.is_owned = false;
35704 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
35707 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) {
35708 LDKThirtyTwoBytes chain_hash_arg_ref;
35709 CHECK(chain_hash_arg->arr_len == 32);
35710 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35711 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
35712 uint64_t ret_ref = 0;
35713 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35714 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35718 static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
35719 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
35720 uint64_t ret_ref = 0;
35721 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35722 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35725 int64_t __attribute__((export_name("TS_GossipTimestampFilter_clone_ptr"))) TS_GossipTimestampFilter_clone_ptr(uint64_t arg) {
35726 LDKGossipTimestampFilter arg_conv;
35727 arg_conv.inner = untag_ptr(arg);
35728 arg_conv.is_owned = ptr_is_owned(arg);
35729 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35730 arg_conv.is_owned = false;
35731 int64_t ret_conv = GossipTimestampFilter_clone_ptr(&arg_conv);
35735 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_clone"))) TS_GossipTimestampFilter_clone(uint64_t orig) {
35736 LDKGossipTimestampFilter orig_conv;
35737 orig_conv.inner = untag_ptr(orig);
35738 orig_conv.is_owned = ptr_is_owned(orig);
35739 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35740 orig_conv.is_owned = false;
35741 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
35742 uint64_t ret_ref = 0;
35743 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35744 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35748 jboolean __attribute__((export_name("TS_GossipTimestampFilter_eq"))) TS_GossipTimestampFilter_eq(uint64_t a, uint64_t b) {
35749 LDKGossipTimestampFilter a_conv;
35750 a_conv.inner = untag_ptr(a);
35751 a_conv.is_owned = ptr_is_owned(a);
35752 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35753 a_conv.is_owned = false;
35754 LDKGossipTimestampFilter b_conv;
35755 b_conv.inner = untag_ptr(b);
35756 b_conv.is_owned = ptr_is_owned(b);
35757 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35758 b_conv.is_owned = false;
35759 jboolean ret_conv = GossipTimestampFilter_eq(&a_conv, &b_conv);
35763 void __attribute__((export_name("TS_ErrorAction_free"))) TS_ErrorAction_free(uint64_t this_ptr) {
35764 if (!ptr_is_owned(this_ptr)) return;
35765 void* this_ptr_ptr = untag_ptr(this_ptr);
35766 CHECK_ACCESS(this_ptr_ptr);
35767 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(this_ptr_ptr);
35768 FREE(untag_ptr(this_ptr));
35769 ErrorAction_free(this_ptr_conv);
35772 static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
35773 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35774 *ret_copy = ErrorAction_clone(arg);
35775 uint64_t ret_ref = tag_ptr(ret_copy, true);
35778 int64_t __attribute__((export_name("TS_ErrorAction_clone_ptr"))) TS_ErrorAction_clone_ptr(uint64_t arg) {
35779 LDKErrorAction* arg_conv = (LDKErrorAction*)untag_ptr(arg);
35780 int64_t ret_conv = ErrorAction_clone_ptr(arg_conv);
35784 uint64_t __attribute__((export_name("TS_ErrorAction_clone"))) TS_ErrorAction_clone(uint64_t orig) {
35785 LDKErrorAction* orig_conv = (LDKErrorAction*)untag_ptr(orig);
35786 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35787 *ret_copy = ErrorAction_clone(orig_conv);
35788 uint64_t ret_ref = tag_ptr(ret_copy, true);
35792 uint64_t __attribute__((export_name("TS_ErrorAction_disconnect_peer"))) TS_ErrorAction_disconnect_peer(uint64_t msg) {
35793 LDKErrorMessage msg_conv;
35794 msg_conv.inner = untag_ptr(msg);
35795 msg_conv.is_owned = ptr_is_owned(msg);
35796 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35797 msg_conv = ErrorMessage_clone(&msg_conv);
35798 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35799 *ret_copy = ErrorAction_disconnect_peer(msg_conv);
35800 uint64_t ret_ref = tag_ptr(ret_copy, true);
35804 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_error"))) TS_ErrorAction_ignore_error() {
35805 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35806 *ret_copy = ErrorAction_ignore_error();
35807 uint64_t ret_ref = tag_ptr(ret_copy, true);
35811 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_and_log"))) TS_ErrorAction_ignore_and_log(uint32_t a) {
35812 LDKLevel a_conv = LDKLevel_from_js(a);
35813 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35814 *ret_copy = ErrorAction_ignore_and_log(a_conv);
35815 uint64_t ret_ref = tag_ptr(ret_copy, true);
35819 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_duplicate_gossip"))) TS_ErrorAction_ignore_duplicate_gossip() {
35820 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35821 *ret_copy = ErrorAction_ignore_duplicate_gossip();
35822 uint64_t ret_ref = tag_ptr(ret_copy, true);
35826 uint64_t __attribute__((export_name("TS_ErrorAction_send_error_message"))) TS_ErrorAction_send_error_message(uint64_t msg) {
35827 LDKErrorMessage msg_conv;
35828 msg_conv.inner = untag_ptr(msg);
35829 msg_conv.is_owned = ptr_is_owned(msg);
35830 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35831 msg_conv = ErrorMessage_clone(&msg_conv);
35832 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35833 *ret_copy = ErrorAction_send_error_message(msg_conv);
35834 uint64_t ret_ref = tag_ptr(ret_copy, true);
35838 uint64_t __attribute__((export_name("TS_ErrorAction_send_warning_message"))) TS_ErrorAction_send_warning_message(uint64_t msg, uint32_t log_level) {
35839 LDKWarningMessage msg_conv;
35840 msg_conv.inner = untag_ptr(msg);
35841 msg_conv.is_owned = ptr_is_owned(msg);
35842 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35843 msg_conv = WarningMessage_clone(&msg_conv);
35844 LDKLevel log_level_conv = LDKLevel_from_js(log_level);
35845 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35846 *ret_copy = ErrorAction_send_warning_message(msg_conv, log_level_conv);
35847 uint64_t ret_ref = tag_ptr(ret_copy, true);
35851 void __attribute__((export_name("TS_LightningError_free"))) TS_LightningError_free(uint64_t this_obj) {
35852 LDKLightningError this_obj_conv;
35853 this_obj_conv.inner = untag_ptr(this_obj);
35854 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35856 LightningError_free(this_obj_conv);
35859 jstring __attribute__((export_name("TS_LightningError_get_err"))) TS_LightningError_get_err(uint64_t this_ptr) {
35860 LDKLightningError this_ptr_conv;
35861 this_ptr_conv.inner = untag_ptr(this_ptr);
35862 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35863 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35864 this_ptr_conv.is_owned = false;
35865 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
35866 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
35871 void __attribute__((export_name("TS_LightningError_set_err"))) TS_LightningError_set_err(uint64_t this_ptr, jstring val) {
35872 LDKLightningError this_ptr_conv;
35873 this_ptr_conv.inner = untag_ptr(this_ptr);
35874 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35876 this_ptr_conv.is_owned = false;
35877 LDKStr val_conv = str_ref_to_owned_c(val);
35878 LightningError_set_err(&this_ptr_conv, val_conv);
35881 uint64_t __attribute__((export_name("TS_LightningError_get_action"))) TS_LightningError_get_action(uint64_t this_ptr) {
35882 LDKLightningError this_ptr_conv;
35883 this_ptr_conv.inner = untag_ptr(this_ptr);
35884 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35886 this_ptr_conv.is_owned = false;
35887 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35888 *ret_copy = LightningError_get_action(&this_ptr_conv);
35889 uint64_t ret_ref = tag_ptr(ret_copy, true);
35893 void __attribute__((export_name("TS_LightningError_set_action"))) TS_LightningError_set_action(uint64_t this_ptr, uint64_t val) {
35894 LDKLightningError this_ptr_conv;
35895 this_ptr_conv.inner = untag_ptr(this_ptr);
35896 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35898 this_ptr_conv.is_owned = false;
35899 void* val_ptr = untag_ptr(val);
35900 CHECK_ACCESS(val_ptr);
35901 LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
35902 val_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(val));
35903 LightningError_set_action(&this_ptr_conv, val_conv);
35906 uint64_t __attribute__((export_name("TS_LightningError_new"))) TS_LightningError_new(jstring err_arg, uint64_t action_arg) {
35907 LDKStr err_arg_conv = str_ref_to_owned_c(err_arg);
35908 void* action_arg_ptr = untag_ptr(action_arg);
35909 CHECK_ACCESS(action_arg_ptr);
35910 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(action_arg_ptr);
35911 action_arg_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action_arg));
35912 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
35913 uint64_t ret_ref = 0;
35914 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35915 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35919 static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
35920 LDKLightningError ret_var = LightningError_clone(arg);
35921 uint64_t ret_ref = 0;
35922 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35923 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35926 int64_t __attribute__((export_name("TS_LightningError_clone_ptr"))) TS_LightningError_clone_ptr(uint64_t arg) {
35927 LDKLightningError arg_conv;
35928 arg_conv.inner = untag_ptr(arg);
35929 arg_conv.is_owned = ptr_is_owned(arg);
35930 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35931 arg_conv.is_owned = false;
35932 int64_t ret_conv = LightningError_clone_ptr(&arg_conv);
35936 uint64_t __attribute__((export_name("TS_LightningError_clone"))) TS_LightningError_clone(uint64_t orig) {
35937 LDKLightningError orig_conv;
35938 orig_conv.inner = untag_ptr(orig);
35939 orig_conv.is_owned = ptr_is_owned(orig);
35940 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35941 orig_conv.is_owned = false;
35942 LDKLightningError ret_var = LightningError_clone(&orig_conv);
35943 uint64_t ret_ref = 0;
35944 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35945 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35949 void __attribute__((export_name("TS_CommitmentUpdate_free"))) TS_CommitmentUpdate_free(uint64_t this_obj) {
35950 LDKCommitmentUpdate this_obj_conv;
35951 this_obj_conv.inner = untag_ptr(this_obj);
35952 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35954 CommitmentUpdate_free(this_obj_conv);
35957 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_add_htlcs"))) TS_CommitmentUpdate_get_update_add_htlcs(uint64_t this_ptr) {
35958 LDKCommitmentUpdate this_ptr_conv;
35959 this_ptr_conv.inner = untag_ptr(this_ptr);
35960 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35962 this_ptr_conv.is_owned = false;
35963 LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
35964 uint64_tArray ret_arr = NULL;
35965 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
35966 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
35967 for (size_t p = 0; p < ret_var.datalen; p++) {
35968 LDKUpdateAddHTLC ret_conv_15_var = ret_var.data[p];
35969 uint64_t ret_conv_15_ref = 0;
35970 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
35971 ret_conv_15_ref = tag_ptr(ret_conv_15_var.inner, ret_conv_15_var.is_owned);
35972 ret_arr_ptr[p] = ret_conv_15_ref;
35975 FREE(ret_var.data);
35979 void __attribute__((export_name("TS_CommitmentUpdate_set_update_add_htlcs"))) TS_CommitmentUpdate_set_update_add_htlcs(uint64_t this_ptr, uint64_tArray val) {
35980 LDKCommitmentUpdate this_ptr_conv;
35981 this_ptr_conv.inner = untag_ptr(this_ptr);
35982 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35984 this_ptr_conv.is_owned = false;
35985 LDKCVec_UpdateAddHTLCZ val_constr;
35986 val_constr.datalen = val->arr_len;
35987 if (val_constr.datalen > 0)
35988 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
35990 val_constr.data = NULL;
35991 uint64_t* val_vals = val->elems;
35992 for (size_t p = 0; p < val_constr.datalen; p++) {
35993 uint64_t val_conv_15 = val_vals[p];
35994 LDKUpdateAddHTLC val_conv_15_conv;
35995 val_conv_15_conv.inner = untag_ptr(val_conv_15);
35996 val_conv_15_conv.is_owned = ptr_is_owned(val_conv_15);
35997 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
35998 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
35999 val_constr.data[p] = val_conv_15_conv;
36002 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
36005 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fulfill_htlcs"))) TS_CommitmentUpdate_get_update_fulfill_htlcs(uint64_t this_ptr) {
36006 LDKCommitmentUpdate this_ptr_conv;
36007 this_ptr_conv.inner = untag_ptr(this_ptr);
36008 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36009 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36010 this_ptr_conv.is_owned = false;
36011 LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
36012 uint64_tArray ret_arr = NULL;
36013 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
36014 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
36015 for (size_t t = 0; t < ret_var.datalen; t++) {
36016 LDKUpdateFulfillHTLC ret_conv_19_var = ret_var.data[t];
36017 uint64_t ret_conv_19_ref = 0;
36018 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
36019 ret_conv_19_ref = tag_ptr(ret_conv_19_var.inner, ret_conv_19_var.is_owned);
36020 ret_arr_ptr[t] = ret_conv_19_ref;
36023 FREE(ret_var.data);
36027 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fulfill_htlcs"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint64_t this_ptr, uint64_tArray val) {
36028 LDKCommitmentUpdate this_ptr_conv;
36029 this_ptr_conv.inner = untag_ptr(this_ptr);
36030 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36032 this_ptr_conv.is_owned = false;
36033 LDKCVec_UpdateFulfillHTLCZ val_constr;
36034 val_constr.datalen = val->arr_len;
36035 if (val_constr.datalen > 0)
36036 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
36038 val_constr.data = NULL;
36039 uint64_t* val_vals = val->elems;
36040 for (size_t t = 0; t < val_constr.datalen; t++) {
36041 uint64_t val_conv_19 = val_vals[t];
36042 LDKUpdateFulfillHTLC val_conv_19_conv;
36043 val_conv_19_conv.inner = untag_ptr(val_conv_19);
36044 val_conv_19_conv.is_owned = ptr_is_owned(val_conv_19);
36045 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
36046 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
36047 val_constr.data[t] = val_conv_19_conv;
36050 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
36053 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_htlcs"))) TS_CommitmentUpdate_get_update_fail_htlcs(uint64_t this_ptr) {
36054 LDKCommitmentUpdate this_ptr_conv;
36055 this_ptr_conv.inner = untag_ptr(this_ptr);
36056 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36058 this_ptr_conv.is_owned = false;
36059 LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
36060 uint64_tArray ret_arr = NULL;
36061 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
36062 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
36063 for (size_t q = 0; q < ret_var.datalen; q++) {
36064 LDKUpdateFailHTLC ret_conv_16_var = ret_var.data[q];
36065 uint64_t ret_conv_16_ref = 0;
36066 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
36067 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
36068 ret_arr_ptr[q] = ret_conv_16_ref;
36071 FREE(ret_var.data);
36075 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_htlcs"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint64_t this_ptr, uint64_tArray val) {
36076 LDKCommitmentUpdate this_ptr_conv;
36077 this_ptr_conv.inner = untag_ptr(this_ptr);
36078 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36080 this_ptr_conv.is_owned = false;
36081 LDKCVec_UpdateFailHTLCZ val_constr;
36082 val_constr.datalen = val->arr_len;
36083 if (val_constr.datalen > 0)
36084 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
36086 val_constr.data = NULL;
36087 uint64_t* val_vals = val->elems;
36088 for (size_t q = 0; q < val_constr.datalen; q++) {
36089 uint64_t val_conv_16 = val_vals[q];
36090 LDKUpdateFailHTLC val_conv_16_conv;
36091 val_conv_16_conv.inner = untag_ptr(val_conv_16);
36092 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
36093 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
36094 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
36095 val_constr.data[q] = val_conv_16_conv;
36098 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
36101 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_get_update_fail_malformed_htlcs(uint64_t this_ptr) {
36102 LDKCommitmentUpdate this_ptr_conv;
36103 this_ptr_conv.inner = untag_ptr(this_ptr);
36104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36106 this_ptr_conv.is_owned = false;
36107 LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
36108 uint64_tArray ret_arr = NULL;
36109 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
36110 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
36111 for (size_t z = 0; z < ret_var.datalen; z++) {
36112 LDKUpdateFailMalformedHTLC ret_conv_25_var = ret_var.data[z];
36113 uint64_t ret_conv_25_ref = 0;
36114 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
36115 ret_conv_25_ref = tag_ptr(ret_conv_25_var.inner, ret_conv_25_var.is_owned);
36116 ret_arr_ptr[z] = ret_conv_25_ref;
36119 FREE(ret_var.data);
36123 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) {
36124 LDKCommitmentUpdate this_ptr_conv;
36125 this_ptr_conv.inner = untag_ptr(this_ptr);
36126 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36128 this_ptr_conv.is_owned = false;
36129 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
36130 val_constr.datalen = val->arr_len;
36131 if (val_constr.datalen > 0)
36132 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
36134 val_constr.data = NULL;
36135 uint64_t* val_vals = val->elems;
36136 for (size_t z = 0; z < val_constr.datalen; z++) {
36137 uint64_t val_conv_25 = val_vals[z];
36138 LDKUpdateFailMalformedHTLC val_conv_25_conv;
36139 val_conv_25_conv.inner = untag_ptr(val_conv_25);
36140 val_conv_25_conv.is_owned = ptr_is_owned(val_conv_25);
36141 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
36142 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
36143 val_constr.data[z] = val_conv_25_conv;
36146 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
36149 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_update_fee"))) TS_CommitmentUpdate_get_update_fee(uint64_t this_ptr) {
36150 LDKCommitmentUpdate this_ptr_conv;
36151 this_ptr_conv.inner = untag_ptr(this_ptr);
36152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36154 this_ptr_conv.is_owned = false;
36155 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
36156 uint64_t ret_ref = 0;
36157 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36158 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36162 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fee"))) TS_CommitmentUpdate_set_update_fee(uint64_t this_ptr, uint64_t val) {
36163 LDKCommitmentUpdate this_ptr_conv;
36164 this_ptr_conv.inner = untag_ptr(this_ptr);
36165 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36167 this_ptr_conv.is_owned = false;
36168 LDKUpdateFee val_conv;
36169 val_conv.inner = untag_ptr(val);
36170 val_conv.is_owned = ptr_is_owned(val);
36171 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36172 val_conv = UpdateFee_clone(&val_conv);
36173 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
36176 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_commitment_signed"))) TS_CommitmentUpdate_get_commitment_signed(uint64_t this_ptr) {
36177 LDKCommitmentUpdate this_ptr_conv;
36178 this_ptr_conv.inner = untag_ptr(this_ptr);
36179 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36180 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36181 this_ptr_conv.is_owned = false;
36182 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
36183 uint64_t ret_ref = 0;
36184 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36185 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36189 void __attribute__((export_name("TS_CommitmentUpdate_set_commitment_signed"))) TS_CommitmentUpdate_set_commitment_signed(uint64_t this_ptr, uint64_t val) {
36190 LDKCommitmentUpdate this_ptr_conv;
36191 this_ptr_conv.inner = untag_ptr(this_ptr);
36192 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36193 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36194 this_ptr_conv.is_owned = false;
36195 LDKCommitmentSigned val_conv;
36196 val_conv.inner = untag_ptr(val);
36197 val_conv.is_owned = ptr_is_owned(val);
36198 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36199 val_conv = CommitmentSigned_clone(&val_conv);
36200 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
36203 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) {
36204 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
36205 update_add_htlcs_arg_constr.datalen = update_add_htlcs_arg->arr_len;
36206 if (update_add_htlcs_arg_constr.datalen > 0)
36207 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
36209 update_add_htlcs_arg_constr.data = NULL;
36210 uint64_t* update_add_htlcs_arg_vals = update_add_htlcs_arg->elems;
36211 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
36212 uint64_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
36213 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
36214 update_add_htlcs_arg_conv_15_conv.inner = untag_ptr(update_add_htlcs_arg_conv_15);
36215 update_add_htlcs_arg_conv_15_conv.is_owned = ptr_is_owned(update_add_htlcs_arg_conv_15);
36216 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
36217 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
36218 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
36220 FREE(update_add_htlcs_arg);
36221 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
36222 update_fulfill_htlcs_arg_constr.datalen = update_fulfill_htlcs_arg->arr_len;
36223 if (update_fulfill_htlcs_arg_constr.datalen > 0)
36224 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
36226 update_fulfill_htlcs_arg_constr.data = NULL;
36227 uint64_t* update_fulfill_htlcs_arg_vals = update_fulfill_htlcs_arg->elems;
36228 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
36229 uint64_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
36230 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
36231 update_fulfill_htlcs_arg_conv_19_conv.inner = untag_ptr(update_fulfill_htlcs_arg_conv_19);
36232 update_fulfill_htlcs_arg_conv_19_conv.is_owned = ptr_is_owned(update_fulfill_htlcs_arg_conv_19);
36233 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
36234 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
36235 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
36237 FREE(update_fulfill_htlcs_arg);
36238 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
36239 update_fail_htlcs_arg_constr.datalen = update_fail_htlcs_arg->arr_len;
36240 if (update_fail_htlcs_arg_constr.datalen > 0)
36241 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
36243 update_fail_htlcs_arg_constr.data = NULL;
36244 uint64_t* update_fail_htlcs_arg_vals = update_fail_htlcs_arg->elems;
36245 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
36246 uint64_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
36247 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
36248 update_fail_htlcs_arg_conv_16_conv.inner = untag_ptr(update_fail_htlcs_arg_conv_16);
36249 update_fail_htlcs_arg_conv_16_conv.is_owned = ptr_is_owned(update_fail_htlcs_arg_conv_16);
36250 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
36251 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
36252 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
36254 FREE(update_fail_htlcs_arg);
36255 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
36256 update_fail_malformed_htlcs_arg_constr.datalen = update_fail_malformed_htlcs_arg->arr_len;
36257 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
36258 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
36260 update_fail_malformed_htlcs_arg_constr.data = NULL;
36261 uint64_t* update_fail_malformed_htlcs_arg_vals = update_fail_malformed_htlcs_arg->elems;
36262 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
36263 uint64_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
36264 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
36265 update_fail_malformed_htlcs_arg_conv_25_conv.inner = untag_ptr(update_fail_malformed_htlcs_arg_conv_25);
36266 update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = ptr_is_owned(update_fail_malformed_htlcs_arg_conv_25);
36267 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
36268 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
36269 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
36271 FREE(update_fail_malformed_htlcs_arg);
36272 LDKUpdateFee update_fee_arg_conv;
36273 update_fee_arg_conv.inner = untag_ptr(update_fee_arg);
36274 update_fee_arg_conv.is_owned = ptr_is_owned(update_fee_arg);
36275 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
36276 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
36277 LDKCommitmentSigned commitment_signed_arg_conv;
36278 commitment_signed_arg_conv.inner = untag_ptr(commitment_signed_arg);
36279 commitment_signed_arg_conv.is_owned = ptr_is_owned(commitment_signed_arg);
36280 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
36281 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
36282 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);
36283 uint64_t ret_ref = 0;
36284 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36285 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36289 static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
36290 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
36291 uint64_t ret_ref = 0;
36292 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36293 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36296 int64_t __attribute__((export_name("TS_CommitmentUpdate_clone_ptr"))) TS_CommitmentUpdate_clone_ptr(uint64_t arg) {
36297 LDKCommitmentUpdate arg_conv;
36298 arg_conv.inner = untag_ptr(arg);
36299 arg_conv.is_owned = ptr_is_owned(arg);
36300 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36301 arg_conv.is_owned = false;
36302 int64_t ret_conv = CommitmentUpdate_clone_ptr(&arg_conv);
36306 uint64_t __attribute__((export_name("TS_CommitmentUpdate_clone"))) TS_CommitmentUpdate_clone(uint64_t orig) {
36307 LDKCommitmentUpdate orig_conv;
36308 orig_conv.inner = untag_ptr(orig);
36309 orig_conv.is_owned = ptr_is_owned(orig);
36310 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36311 orig_conv.is_owned = false;
36312 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
36313 uint64_t ret_ref = 0;
36314 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36315 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36319 jboolean __attribute__((export_name("TS_CommitmentUpdate_eq"))) TS_CommitmentUpdate_eq(uint64_t a, uint64_t b) {
36320 LDKCommitmentUpdate a_conv;
36321 a_conv.inner = untag_ptr(a);
36322 a_conv.is_owned = ptr_is_owned(a);
36323 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36324 a_conv.is_owned = false;
36325 LDKCommitmentUpdate b_conv;
36326 b_conv.inner = untag_ptr(b);
36327 b_conv.is_owned = ptr_is_owned(b);
36328 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36329 b_conv.is_owned = false;
36330 jboolean ret_conv = CommitmentUpdate_eq(&a_conv, &b_conv);
36334 void __attribute__((export_name("TS_ChannelMessageHandler_free"))) TS_ChannelMessageHandler_free(uint64_t this_ptr) {
36335 if (!ptr_is_owned(this_ptr)) return;
36336 void* this_ptr_ptr = untag_ptr(this_ptr);
36337 CHECK_ACCESS(this_ptr_ptr);
36338 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(this_ptr_ptr);
36339 FREE(untag_ptr(this_ptr));
36340 ChannelMessageHandler_free(this_ptr_conv);
36343 void __attribute__((export_name("TS_RoutingMessageHandler_free"))) TS_RoutingMessageHandler_free(uint64_t this_ptr) {
36344 if (!ptr_is_owned(this_ptr)) return;
36345 void* this_ptr_ptr = untag_ptr(this_ptr);
36346 CHECK_ACCESS(this_ptr_ptr);
36347 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(this_ptr_ptr);
36348 FREE(untag_ptr(this_ptr));
36349 RoutingMessageHandler_free(this_ptr_conv);
36352 void __attribute__((export_name("TS_OnionMessageHandler_free"))) TS_OnionMessageHandler_free(uint64_t this_ptr) {
36353 if (!ptr_is_owned(this_ptr)) return;
36354 void* this_ptr_ptr = untag_ptr(this_ptr);
36355 CHECK_ACCESS(this_ptr_ptr);
36356 LDKOnionMessageHandler this_ptr_conv = *(LDKOnionMessageHandler*)(this_ptr_ptr);
36357 FREE(untag_ptr(this_ptr));
36358 OnionMessageHandler_free(this_ptr_conv);
36361 int8_tArray __attribute__((export_name("TS_AcceptChannel_write"))) TS_AcceptChannel_write(uint64_t obj) {
36362 LDKAcceptChannel obj_conv;
36363 obj_conv.inner = untag_ptr(obj);
36364 obj_conv.is_owned = ptr_is_owned(obj);
36365 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36366 obj_conv.is_owned = false;
36367 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
36368 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36369 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36370 CVec_u8Z_free(ret_var);
36374 uint64_t __attribute__((export_name("TS_AcceptChannel_read"))) TS_AcceptChannel_read(int8_tArray ser) {
36375 LDKu8slice ser_ref;
36376 ser_ref.datalen = ser->arr_len;
36377 ser_ref.data = ser->elems;
36378 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
36379 *ret_conv = AcceptChannel_read(ser_ref);
36381 return tag_ptr(ret_conv, true);
36384 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_write"))) TS_AnnouncementSignatures_write(uint64_t obj) {
36385 LDKAnnouncementSignatures obj_conv;
36386 obj_conv.inner = untag_ptr(obj);
36387 obj_conv.is_owned = ptr_is_owned(obj);
36388 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36389 obj_conv.is_owned = false;
36390 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
36391 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36392 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36393 CVec_u8Z_free(ret_var);
36397 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_read"))) TS_AnnouncementSignatures_read(int8_tArray ser) {
36398 LDKu8slice ser_ref;
36399 ser_ref.datalen = ser->arr_len;
36400 ser_ref.data = ser->elems;
36401 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
36402 *ret_conv = AnnouncementSignatures_read(ser_ref);
36404 return tag_ptr(ret_conv, true);
36407 int8_tArray __attribute__((export_name("TS_ChannelReestablish_write"))) TS_ChannelReestablish_write(uint64_t obj) {
36408 LDKChannelReestablish obj_conv;
36409 obj_conv.inner = untag_ptr(obj);
36410 obj_conv.is_owned = ptr_is_owned(obj);
36411 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36412 obj_conv.is_owned = false;
36413 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
36414 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36415 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36416 CVec_u8Z_free(ret_var);
36420 uint64_t __attribute__((export_name("TS_ChannelReestablish_read"))) TS_ChannelReestablish_read(int8_tArray ser) {
36421 LDKu8slice ser_ref;
36422 ser_ref.datalen = ser->arr_len;
36423 ser_ref.data = ser->elems;
36424 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
36425 *ret_conv = ChannelReestablish_read(ser_ref);
36427 return tag_ptr(ret_conv, true);
36430 int8_tArray __attribute__((export_name("TS_ClosingSigned_write"))) TS_ClosingSigned_write(uint64_t obj) {
36431 LDKClosingSigned obj_conv;
36432 obj_conv.inner = untag_ptr(obj);
36433 obj_conv.is_owned = ptr_is_owned(obj);
36434 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36435 obj_conv.is_owned = false;
36436 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
36437 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36438 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36439 CVec_u8Z_free(ret_var);
36443 uint64_t __attribute__((export_name("TS_ClosingSigned_read"))) TS_ClosingSigned_read(int8_tArray ser) {
36444 LDKu8slice ser_ref;
36445 ser_ref.datalen = ser->arr_len;
36446 ser_ref.data = ser->elems;
36447 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
36448 *ret_conv = ClosingSigned_read(ser_ref);
36450 return tag_ptr(ret_conv, true);
36453 int8_tArray __attribute__((export_name("TS_ClosingSignedFeeRange_write"))) TS_ClosingSignedFeeRange_write(uint64_t obj) {
36454 LDKClosingSignedFeeRange obj_conv;
36455 obj_conv.inner = untag_ptr(obj);
36456 obj_conv.is_owned = ptr_is_owned(obj);
36457 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36458 obj_conv.is_owned = false;
36459 LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
36460 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36461 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36462 CVec_u8Z_free(ret_var);
36466 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_read"))) TS_ClosingSignedFeeRange_read(int8_tArray ser) {
36467 LDKu8slice ser_ref;
36468 ser_ref.datalen = ser->arr_len;
36469 ser_ref.data = ser->elems;
36470 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
36471 *ret_conv = ClosingSignedFeeRange_read(ser_ref);
36473 return tag_ptr(ret_conv, true);
36476 int8_tArray __attribute__((export_name("TS_CommitmentSigned_write"))) TS_CommitmentSigned_write(uint64_t obj) {
36477 LDKCommitmentSigned obj_conv;
36478 obj_conv.inner = untag_ptr(obj);
36479 obj_conv.is_owned = ptr_is_owned(obj);
36480 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36481 obj_conv.is_owned = false;
36482 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
36483 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36484 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36485 CVec_u8Z_free(ret_var);
36489 uint64_t __attribute__((export_name("TS_CommitmentSigned_read"))) TS_CommitmentSigned_read(int8_tArray ser) {
36490 LDKu8slice ser_ref;
36491 ser_ref.datalen = ser->arr_len;
36492 ser_ref.data = ser->elems;
36493 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
36494 *ret_conv = CommitmentSigned_read(ser_ref);
36496 return tag_ptr(ret_conv, true);
36499 int8_tArray __attribute__((export_name("TS_FundingCreated_write"))) TS_FundingCreated_write(uint64_t obj) {
36500 LDKFundingCreated obj_conv;
36501 obj_conv.inner = untag_ptr(obj);
36502 obj_conv.is_owned = ptr_is_owned(obj);
36503 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36504 obj_conv.is_owned = false;
36505 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
36506 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36507 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36508 CVec_u8Z_free(ret_var);
36512 uint64_t __attribute__((export_name("TS_FundingCreated_read"))) TS_FundingCreated_read(int8_tArray ser) {
36513 LDKu8slice ser_ref;
36514 ser_ref.datalen = ser->arr_len;
36515 ser_ref.data = ser->elems;
36516 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
36517 *ret_conv = FundingCreated_read(ser_ref);
36519 return tag_ptr(ret_conv, true);
36522 int8_tArray __attribute__((export_name("TS_FundingSigned_write"))) TS_FundingSigned_write(uint64_t obj) {
36523 LDKFundingSigned obj_conv;
36524 obj_conv.inner = untag_ptr(obj);
36525 obj_conv.is_owned = ptr_is_owned(obj);
36526 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36527 obj_conv.is_owned = false;
36528 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
36529 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36530 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36531 CVec_u8Z_free(ret_var);
36535 uint64_t __attribute__((export_name("TS_FundingSigned_read"))) TS_FundingSigned_read(int8_tArray ser) {
36536 LDKu8slice ser_ref;
36537 ser_ref.datalen = ser->arr_len;
36538 ser_ref.data = ser->elems;
36539 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
36540 *ret_conv = FundingSigned_read(ser_ref);
36542 return tag_ptr(ret_conv, true);
36545 int8_tArray __attribute__((export_name("TS_ChannelReady_write"))) TS_ChannelReady_write(uint64_t obj) {
36546 LDKChannelReady obj_conv;
36547 obj_conv.inner = untag_ptr(obj);
36548 obj_conv.is_owned = ptr_is_owned(obj);
36549 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36550 obj_conv.is_owned = false;
36551 LDKCVec_u8Z ret_var = ChannelReady_write(&obj_conv);
36552 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36553 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36554 CVec_u8Z_free(ret_var);
36558 uint64_t __attribute__((export_name("TS_ChannelReady_read"))) TS_ChannelReady_read(int8_tArray ser) {
36559 LDKu8slice ser_ref;
36560 ser_ref.datalen = ser->arr_len;
36561 ser_ref.data = ser->elems;
36562 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
36563 *ret_conv = ChannelReady_read(ser_ref);
36565 return tag_ptr(ret_conv, true);
36568 int8_tArray __attribute__((export_name("TS_Init_write"))) TS_Init_write(uint64_t obj) {
36570 obj_conv.inner = untag_ptr(obj);
36571 obj_conv.is_owned = ptr_is_owned(obj);
36572 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36573 obj_conv.is_owned = false;
36574 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
36575 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36576 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36577 CVec_u8Z_free(ret_var);
36581 uint64_t __attribute__((export_name("TS_Init_read"))) TS_Init_read(int8_tArray ser) {
36582 LDKu8slice ser_ref;
36583 ser_ref.datalen = ser->arr_len;
36584 ser_ref.data = ser->elems;
36585 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
36586 *ret_conv = Init_read(ser_ref);
36588 return tag_ptr(ret_conv, true);
36591 int8_tArray __attribute__((export_name("TS_OpenChannel_write"))) TS_OpenChannel_write(uint64_t obj) {
36592 LDKOpenChannel obj_conv;
36593 obj_conv.inner = untag_ptr(obj);
36594 obj_conv.is_owned = ptr_is_owned(obj);
36595 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36596 obj_conv.is_owned = false;
36597 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
36598 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36599 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36600 CVec_u8Z_free(ret_var);
36604 uint64_t __attribute__((export_name("TS_OpenChannel_read"))) TS_OpenChannel_read(int8_tArray ser) {
36605 LDKu8slice ser_ref;
36606 ser_ref.datalen = ser->arr_len;
36607 ser_ref.data = ser->elems;
36608 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
36609 *ret_conv = OpenChannel_read(ser_ref);
36611 return tag_ptr(ret_conv, true);
36614 int8_tArray __attribute__((export_name("TS_RevokeAndACK_write"))) TS_RevokeAndACK_write(uint64_t obj) {
36615 LDKRevokeAndACK obj_conv;
36616 obj_conv.inner = untag_ptr(obj);
36617 obj_conv.is_owned = ptr_is_owned(obj);
36618 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36619 obj_conv.is_owned = false;
36620 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
36621 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36622 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36623 CVec_u8Z_free(ret_var);
36627 uint64_t __attribute__((export_name("TS_RevokeAndACK_read"))) TS_RevokeAndACK_read(int8_tArray ser) {
36628 LDKu8slice ser_ref;
36629 ser_ref.datalen = ser->arr_len;
36630 ser_ref.data = ser->elems;
36631 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
36632 *ret_conv = RevokeAndACK_read(ser_ref);
36634 return tag_ptr(ret_conv, true);
36637 int8_tArray __attribute__((export_name("TS_Shutdown_write"))) TS_Shutdown_write(uint64_t obj) {
36638 LDKShutdown obj_conv;
36639 obj_conv.inner = untag_ptr(obj);
36640 obj_conv.is_owned = ptr_is_owned(obj);
36641 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36642 obj_conv.is_owned = false;
36643 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
36644 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36645 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36646 CVec_u8Z_free(ret_var);
36650 uint64_t __attribute__((export_name("TS_Shutdown_read"))) TS_Shutdown_read(int8_tArray ser) {
36651 LDKu8slice ser_ref;
36652 ser_ref.datalen = ser->arr_len;
36653 ser_ref.data = ser->elems;
36654 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
36655 *ret_conv = Shutdown_read(ser_ref);
36657 return tag_ptr(ret_conv, true);
36660 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_write"))) TS_UpdateFailHTLC_write(uint64_t obj) {
36661 LDKUpdateFailHTLC obj_conv;
36662 obj_conv.inner = untag_ptr(obj);
36663 obj_conv.is_owned = ptr_is_owned(obj);
36664 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36665 obj_conv.is_owned = false;
36666 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
36667 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36668 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36669 CVec_u8Z_free(ret_var);
36673 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_read"))) TS_UpdateFailHTLC_read(int8_tArray ser) {
36674 LDKu8slice ser_ref;
36675 ser_ref.datalen = ser->arr_len;
36676 ser_ref.data = ser->elems;
36677 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
36678 *ret_conv = UpdateFailHTLC_read(ser_ref);
36680 return tag_ptr(ret_conv, true);
36683 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_write"))) TS_UpdateFailMalformedHTLC_write(uint64_t obj) {
36684 LDKUpdateFailMalformedHTLC obj_conv;
36685 obj_conv.inner = untag_ptr(obj);
36686 obj_conv.is_owned = ptr_is_owned(obj);
36687 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36688 obj_conv.is_owned = false;
36689 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
36690 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36691 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36692 CVec_u8Z_free(ret_var);
36696 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_read"))) TS_UpdateFailMalformedHTLC_read(int8_tArray ser) {
36697 LDKu8slice ser_ref;
36698 ser_ref.datalen = ser->arr_len;
36699 ser_ref.data = ser->elems;
36700 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
36701 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
36703 return tag_ptr(ret_conv, true);
36706 int8_tArray __attribute__((export_name("TS_UpdateFee_write"))) TS_UpdateFee_write(uint64_t obj) {
36707 LDKUpdateFee obj_conv;
36708 obj_conv.inner = untag_ptr(obj);
36709 obj_conv.is_owned = ptr_is_owned(obj);
36710 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36711 obj_conv.is_owned = false;
36712 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
36713 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36714 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36715 CVec_u8Z_free(ret_var);
36719 uint64_t __attribute__((export_name("TS_UpdateFee_read"))) TS_UpdateFee_read(int8_tArray ser) {
36720 LDKu8slice ser_ref;
36721 ser_ref.datalen = ser->arr_len;
36722 ser_ref.data = ser->elems;
36723 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
36724 *ret_conv = UpdateFee_read(ser_ref);
36726 return tag_ptr(ret_conv, true);
36729 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_write"))) TS_UpdateFulfillHTLC_write(uint64_t obj) {
36730 LDKUpdateFulfillHTLC obj_conv;
36731 obj_conv.inner = untag_ptr(obj);
36732 obj_conv.is_owned = ptr_is_owned(obj);
36733 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36734 obj_conv.is_owned = false;
36735 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
36736 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36737 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36738 CVec_u8Z_free(ret_var);
36742 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_read"))) TS_UpdateFulfillHTLC_read(int8_tArray ser) {
36743 LDKu8slice ser_ref;
36744 ser_ref.datalen = ser->arr_len;
36745 ser_ref.data = ser->elems;
36746 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
36747 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
36749 return tag_ptr(ret_conv, true);
36752 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_write"))) TS_UpdateAddHTLC_write(uint64_t obj) {
36753 LDKUpdateAddHTLC obj_conv;
36754 obj_conv.inner = untag_ptr(obj);
36755 obj_conv.is_owned = ptr_is_owned(obj);
36756 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36757 obj_conv.is_owned = false;
36758 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
36759 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36760 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36761 CVec_u8Z_free(ret_var);
36765 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_read"))) TS_UpdateAddHTLC_read(int8_tArray ser) {
36766 LDKu8slice ser_ref;
36767 ser_ref.datalen = ser->arr_len;
36768 ser_ref.data = ser->elems;
36769 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
36770 *ret_conv = UpdateAddHTLC_read(ser_ref);
36772 return tag_ptr(ret_conv, true);
36775 uint64_t __attribute__((export_name("TS_OnionMessage_read"))) TS_OnionMessage_read(int8_tArray ser) {
36776 LDKu8slice ser_ref;
36777 ser_ref.datalen = ser->arr_len;
36778 ser_ref.data = ser->elems;
36779 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
36780 *ret_conv = OnionMessage_read(ser_ref);
36782 return tag_ptr(ret_conv, true);
36785 int8_tArray __attribute__((export_name("TS_OnionMessage_write"))) TS_OnionMessage_write(uint64_t obj) {
36786 LDKOnionMessage obj_conv;
36787 obj_conv.inner = untag_ptr(obj);
36788 obj_conv.is_owned = ptr_is_owned(obj);
36789 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36790 obj_conv.is_owned = false;
36791 LDKCVec_u8Z ret_var = OnionMessage_write(&obj_conv);
36792 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36793 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36794 CVec_u8Z_free(ret_var);
36798 int8_tArray __attribute__((export_name("TS_Ping_write"))) TS_Ping_write(uint64_t obj) {
36800 obj_conv.inner = untag_ptr(obj);
36801 obj_conv.is_owned = ptr_is_owned(obj);
36802 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36803 obj_conv.is_owned = false;
36804 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
36805 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36806 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36807 CVec_u8Z_free(ret_var);
36811 uint64_t __attribute__((export_name("TS_Ping_read"))) TS_Ping_read(int8_tArray ser) {
36812 LDKu8slice ser_ref;
36813 ser_ref.datalen = ser->arr_len;
36814 ser_ref.data = ser->elems;
36815 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
36816 *ret_conv = Ping_read(ser_ref);
36818 return tag_ptr(ret_conv, true);
36821 int8_tArray __attribute__((export_name("TS_Pong_write"))) TS_Pong_write(uint64_t obj) {
36823 obj_conv.inner = untag_ptr(obj);
36824 obj_conv.is_owned = ptr_is_owned(obj);
36825 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36826 obj_conv.is_owned = false;
36827 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
36828 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36829 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36830 CVec_u8Z_free(ret_var);
36834 uint64_t __attribute__((export_name("TS_Pong_read"))) TS_Pong_read(int8_tArray ser) {
36835 LDKu8slice ser_ref;
36836 ser_ref.datalen = ser->arr_len;
36837 ser_ref.data = ser->elems;
36838 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
36839 *ret_conv = Pong_read(ser_ref);
36841 return tag_ptr(ret_conv, true);
36844 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_write"))) TS_UnsignedChannelAnnouncement_write(uint64_t obj) {
36845 LDKUnsignedChannelAnnouncement obj_conv;
36846 obj_conv.inner = untag_ptr(obj);
36847 obj_conv.is_owned = ptr_is_owned(obj);
36848 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36849 obj_conv.is_owned = false;
36850 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
36851 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36852 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36853 CVec_u8Z_free(ret_var);
36857 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_read"))) TS_UnsignedChannelAnnouncement_read(int8_tArray ser) {
36858 LDKu8slice ser_ref;
36859 ser_ref.datalen = ser->arr_len;
36860 ser_ref.data = ser->elems;
36861 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
36862 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
36864 return tag_ptr(ret_conv, true);
36867 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_write"))) TS_ChannelAnnouncement_write(uint64_t obj) {
36868 LDKChannelAnnouncement obj_conv;
36869 obj_conv.inner = untag_ptr(obj);
36870 obj_conv.is_owned = ptr_is_owned(obj);
36871 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36872 obj_conv.is_owned = false;
36873 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
36874 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36875 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36876 CVec_u8Z_free(ret_var);
36880 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_read"))) TS_ChannelAnnouncement_read(int8_tArray ser) {
36881 LDKu8slice ser_ref;
36882 ser_ref.datalen = ser->arr_len;
36883 ser_ref.data = ser->elems;
36884 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
36885 *ret_conv = ChannelAnnouncement_read(ser_ref);
36887 return tag_ptr(ret_conv, true);
36890 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_write"))) TS_UnsignedChannelUpdate_write(uint64_t obj) {
36891 LDKUnsignedChannelUpdate obj_conv;
36892 obj_conv.inner = untag_ptr(obj);
36893 obj_conv.is_owned = ptr_is_owned(obj);
36894 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36895 obj_conv.is_owned = false;
36896 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
36897 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36898 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36899 CVec_u8Z_free(ret_var);
36903 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_read"))) TS_UnsignedChannelUpdate_read(int8_tArray ser) {
36904 LDKu8slice ser_ref;
36905 ser_ref.datalen = ser->arr_len;
36906 ser_ref.data = ser->elems;
36907 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
36908 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
36910 return tag_ptr(ret_conv, true);
36913 int8_tArray __attribute__((export_name("TS_ChannelUpdate_write"))) TS_ChannelUpdate_write(uint64_t obj) {
36914 LDKChannelUpdate obj_conv;
36915 obj_conv.inner = untag_ptr(obj);
36916 obj_conv.is_owned = ptr_is_owned(obj);
36917 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36918 obj_conv.is_owned = false;
36919 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
36920 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36921 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36922 CVec_u8Z_free(ret_var);
36926 uint64_t __attribute__((export_name("TS_ChannelUpdate_read"))) TS_ChannelUpdate_read(int8_tArray ser) {
36927 LDKu8slice ser_ref;
36928 ser_ref.datalen = ser->arr_len;
36929 ser_ref.data = ser->elems;
36930 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
36931 *ret_conv = ChannelUpdate_read(ser_ref);
36933 return tag_ptr(ret_conv, true);
36936 int8_tArray __attribute__((export_name("TS_ErrorMessage_write"))) TS_ErrorMessage_write(uint64_t obj) {
36937 LDKErrorMessage obj_conv;
36938 obj_conv.inner = untag_ptr(obj);
36939 obj_conv.is_owned = ptr_is_owned(obj);
36940 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36941 obj_conv.is_owned = false;
36942 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
36943 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36944 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36945 CVec_u8Z_free(ret_var);
36949 uint64_t __attribute__((export_name("TS_ErrorMessage_read"))) TS_ErrorMessage_read(int8_tArray ser) {
36950 LDKu8slice ser_ref;
36951 ser_ref.datalen = ser->arr_len;
36952 ser_ref.data = ser->elems;
36953 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
36954 *ret_conv = ErrorMessage_read(ser_ref);
36956 return tag_ptr(ret_conv, true);
36959 int8_tArray __attribute__((export_name("TS_WarningMessage_write"))) TS_WarningMessage_write(uint64_t obj) {
36960 LDKWarningMessage obj_conv;
36961 obj_conv.inner = untag_ptr(obj);
36962 obj_conv.is_owned = ptr_is_owned(obj);
36963 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36964 obj_conv.is_owned = false;
36965 LDKCVec_u8Z ret_var = WarningMessage_write(&obj_conv);
36966 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36967 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36968 CVec_u8Z_free(ret_var);
36972 uint64_t __attribute__((export_name("TS_WarningMessage_read"))) TS_WarningMessage_read(int8_tArray ser) {
36973 LDKu8slice ser_ref;
36974 ser_ref.datalen = ser->arr_len;
36975 ser_ref.data = ser->elems;
36976 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
36977 *ret_conv = WarningMessage_read(ser_ref);
36979 return tag_ptr(ret_conv, true);
36982 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_write"))) TS_UnsignedNodeAnnouncement_write(uint64_t obj) {
36983 LDKUnsignedNodeAnnouncement obj_conv;
36984 obj_conv.inner = untag_ptr(obj);
36985 obj_conv.is_owned = ptr_is_owned(obj);
36986 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36987 obj_conv.is_owned = false;
36988 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
36989 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36990 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36991 CVec_u8Z_free(ret_var);
36995 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_read"))) TS_UnsignedNodeAnnouncement_read(int8_tArray ser) {
36996 LDKu8slice ser_ref;
36997 ser_ref.datalen = ser->arr_len;
36998 ser_ref.data = ser->elems;
36999 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
37000 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
37002 return tag_ptr(ret_conv, true);
37005 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_write"))) TS_NodeAnnouncement_write(uint64_t obj) {
37006 LDKNodeAnnouncement obj_conv;
37007 obj_conv.inner = untag_ptr(obj);
37008 obj_conv.is_owned = ptr_is_owned(obj);
37009 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37010 obj_conv.is_owned = false;
37011 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
37012 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37013 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37014 CVec_u8Z_free(ret_var);
37018 uint64_t __attribute__((export_name("TS_NodeAnnouncement_read"))) TS_NodeAnnouncement_read(int8_tArray ser) {
37019 LDKu8slice ser_ref;
37020 ser_ref.datalen = ser->arr_len;
37021 ser_ref.data = ser->elems;
37022 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
37023 *ret_conv = NodeAnnouncement_read(ser_ref);
37025 return tag_ptr(ret_conv, true);
37028 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_read"))) TS_QueryShortChannelIds_read(int8_tArray ser) {
37029 LDKu8slice ser_ref;
37030 ser_ref.datalen = ser->arr_len;
37031 ser_ref.data = ser->elems;
37032 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
37033 *ret_conv = QueryShortChannelIds_read(ser_ref);
37035 return tag_ptr(ret_conv, true);
37038 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_write"))) TS_QueryShortChannelIds_write(uint64_t obj) {
37039 LDKQueryShortChannelIds obj_conv;
37040 obj_conv.inner = untag_ptr(obj);
37041 obj_conv.is_owned = ptr_is_owned(obj);
37042 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37043 obj_conv.is_owned = false;
37044 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
37045 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37046 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37047 CVec_u8Z_free(ret_var);
37051 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_write"))) TS_ReplyShortChannelIdsEnd_write(uint64_t obj) {
37052 LDKReplyShortChannelIdsEnd obj_conv;
37053 obj_conv.inner = untag_ptr(obj);
37054 obj_conv.is_owned = ptr_is_owned(obj);
37055 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37056 obj_conv.is_owned = false;
37057 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
37058 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37059 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37060 CVec_u8Z_free(ret_var);
37064 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_read"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) {
37065 LDKu8slice ser_ref;
37066 ser_ref.datalen = ser->arr_len;
37067 ser_ref.data = ser->elems;
37068 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
37069 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
37071 return tag_ptr(ret_conv, true);
37074 int32_t __attribute__((export_name("TS_QueryChannelRange_end_blocknum"))) TS_QueryChannelRange_end_blocknum(uint64_t this_arg) {
37075 LDKQueryChannelRange this_arg_conv;
37076 this_arg_conv.inner = untag_ptr(this_arg);
37077 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37078 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37079 this_arg_conv.is_owned = false;
37080 int32_t ret_conv = QueryChannelRange_end_blocknum(&this_arg_conv);
37084 int8_tArray __attribute__((export_name("TS_QueryChannelRange_write"))) TS_QueryChannelRange_write(uint64_t obj) {
37085 LDKQueryChannelRange obj_conv;
37086 obj_conv.inner = untag_ptr(obj);
37087 obj_conv.is_owned = ptr_is_owned(obj);
37088 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37089 obj_conv.is_owned = false;
37090 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
37091 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37092 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37093 CVec_u8Z_free(ret_var);
37097 uint64_t __attribute__((export_name("TS_QueryChannelRange_read"))) TS_QueryChannelRange_read(int8_tArray ser) {
37098 LDKu8slice ser_ref;
37099 ser_ref.datalen = ser->arr_len;
37100 ser_ref.data = ser->elems;
37101 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
37102 *ret_conv = QueryChannelRange_read(ser_ref);
37104 return tag_ptr(ret_conv, true);
37107 uint64_t __attribute__((export_name("TS_ReplyChannelRange_read"))) TS_ReplyChannelRange_read(int8_tArray ser) {
37108 LDKu8slice ser_ref;
37109 ser_ref.datalen = ser->arr_len;
37110 ser_ref.data = ser->elems;
37111 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
37112 *ret_conv = ReplyChannelRange_read(ser_ref);
37114 return tag_ptr(ret_conv, true);
37117 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_write"))) TS_ReplyChannelRange_write(uint64_t obj) {
37118 LDKReplyChannelRange obj_conv;
37119 obj_conv.inner = untag_ptr(obj);
37120 obj_conv.is_owned = ptr_is_owned(obj);
37121 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37122 obj_conv.is_owned = false;
37123 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
37124 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37125 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37126 CVec_u8Z_free(ret_var);
37130 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_write"))) TS_GossipTimestampFilter_write(uint64_t obj) {
37131 LDKGossipTimestampFilter obj_conv;
37132 obj_conv.inner = untag_ptr(obj);
37133 obj_conv.is_owned = ptr_is_owned(obj);
37134 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37135 obj_conv.is_owned = false;
37136 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
37137 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37138 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37139 CVec_u8Z_free(ret_var);
37143 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_read"))) TS_GossipTimestampFilter_read(int8_tArray ser) {
37144 LDKu8slice ser_ref;
37145 ser_ref.datalen = ser->arr_len;
37146 ser_ref.data = ser->elems;
37147 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
37148 *ret_conv = GossipTimestampFilter_read(ser_ref);
37150 return tag_ptr(ret_conv, true);
37153 void __attribute__((export_name("TS_CustomMessageHandler_free"))) TS_CustomMessageHandler_free(uint64_t this_ptr) {
37154 if (!ptr_is_owned(this_ptr)) return;
37155 void* this_ptr_ptr = untag_ptr(this_ptr);
37156 CHECK_ACCESS(this_ptr_ptr);
37157 LDKCustomMessageHandler this_ptr_conv = *(LDKCustomMessageHandler*)(this_ptr_ptr);
37158 FREE(untag_ptr(this_ptr));
37159 CustomMessageHandler_free(this_ptr_conv);
37162 void __attribute__((export_name("TS_IgnoringMessageHandler_free"))) TS_IgnoringMessageHandler_free(uint64_t this_obj) {
37163 LDKIgnoringMessageHandler this_obj_conv;
37164 this_obj_conv.inner = untag_ptr(this_obj);
37165 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37167 IgnoringMessageHandler_free(this_obj_conv);
37170 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_new"))) TS_IgnoringMessageHandler_new() {
37171 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
37172 uint64_t ret_ref = 0;
37173 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37174 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37178 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_MessageSendEventsProvider"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
37179 LDKIgnoringMessageHandler this_arg_conv;
37180 this_arg_conv.inner = untag_ptr(this_arg);
37181 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37182 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37183 this_arg_conv.is_owned = false;
37184 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
37185 *ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
37186 return tag_ptr(ret_ret, true);
37189 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_RoutingMessageHandler"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint64_t this_arg) {
37190 LDKIgnoringMessageHandler this_arg_conv;
37191 this_arg_conv.inner = untag_ptr(this_arg);
37192 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37193 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37194 this_arg_conv.is_owned = false;
37195 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
37196 *ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
37197 return tag_ptr(ret_ret, true);
37200 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageProvider"))) TS_IgnoringMessageHandler_as_OnionMessageProvider(uint64_t this_arg) {
37201 LDKIgnoringMessageHandler this_arg_conv;
37202 this_arg_conv.inner = untag_ptr(this_arg);
37203 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37204 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37205 this_arg_conv.is_owned = false;
37206 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
37207 *ret_ret = IgnoringMessageHandler_as_OnionMessageProvider(&this_arg_conv);
37208 return tag_ptr(ret_ret, true);
37211 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageHandler"))) TS_IgnoringMessageHandler_as_OnionMessageHandler(uint64_t this_arg) {
37212 LDKIgnoringMessageHandler this_arg_conv;
37213 this_arg_conv.inner = untag_ptr(this_arg);
37214 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37215 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37216 this_arg_conv.is_owned = false;
37217 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
37218 *ret_ret = IgnoringMessageHandler_as_OnionMessageHandler(&this_arg_conv);
37219 return tag_ptr(ret_ret, true);
37222 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomOnionMessageHandler"))) TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(uint64_t this_arg) {
37223 LDKIgnoringMessageHandler this_arg_conv;
37224 this_arg_conv.inner = untag_ptr(this_arg);
37225 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37226 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37227 this_arg_conv.is_owned = false;
37228 LDKCustomOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
37229 *ret_ret = IgnoringMessageHandler_as_CustomOnionMessageHandler(&this_arg_conv);
37230 return tag_ptr(ret_ret, true);
37233 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageReader"))) TS_IgnoringMessageHandler_as_CustomMessageReader(uint64_t this_arg) {
37234 LDKIgnoringMessageHandler this_arg_conv;
37235 this_arg_conv.inner = untag_ptr(this_arg);
37236 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37238 this_arg_conv.is_owned = false;
37239 LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
37240 *ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
37241 return tag_ptr(ret_ret, true);
37244 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageHandler"))) TS_IgnoringMessageHandler_as_CustomMessageHandler(uint64_t this_arg) {
37245 LDKIgnoringMessageHandler this_arg_conv;
37246 this_arg_conv.inner = untag_ptr(this_arg);
37247 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37249 this_arg_conv.is_owned = false;
37250 LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
37251 *ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
37252 return tag_ptr(ret_ret, true);
37255 void __attribute__((export_name("TS_ErroringMessageHandler_free"))) TS_ErroringMessageHandler_free(uint64_t this_obj) {
37256 LDKErroringMessageHandler this_obj_conv;
37257 this_obj_conv.inner = untag_ptr(this_obj);
37258 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37260 ErroringMessageHandler_free(this_obj_conv);
37263 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_new"))) TS_ErroringMessageHandler_new() {
37264 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
37265 uint64_t ret_ref = 0;
37266 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37267 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37271 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_MessageSendEventsProvider"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
37272 LDKErroringMessageHandler this_arg_conv;
37273 this_arg_conv.inner = untag_ptr(this_arg);
37274 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37276 this_arg_conv.is_owned = false;
37277 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
37278 *ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
37279 return tag_ptr(ret_ret, true);
37282 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_ChannelMessageHandler"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint64_t this_arg) {
37283 LDKErroringMessageHandler this_arg_conv;
37284 this_arg_conv.inner = untag_ptr(this_arg);
37285 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37287 this_arg_conv.is_owned = false;
37288 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
37289 *ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
37290 return tag_ptr(ret_ret, true);
37293 void __attribute__((export_name("TS_MessageHandler_free"))) TS_MessageHandler_free(uint64_t this_obj) {
37294 LDKMessageHandler this_obj_conv;
37295 this_obj_conv.inner = untag_ptr(this_obj);
37296 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37297 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37298 MessageHandler_free(this_obj_conv);
37301 uint64_t __attribute__((export_name("TS_MessageHandler_get_chan_handler"))) TS_MessageHandler_get_chan_handler(uint64_t this_ptr) {
37302 LDKMessageHandler this_ptr_conv;
37303 this_ptr_conv.inner = untag_ptr(this_ptr);
37304 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37306 this_ptr_conv.is_owned = false;
37307 // WARNING: This object doesn't live past this scope, needs clone!
37308 uint64_t ret_ret = tag_ptr(MessageHandler_get_chan_handler(&this_ptr_conv), false);
37312 void __attribute__((export_name("TS_MessageHandler_set_chan_handler"))) TS_MessageHandler_set_chan_handler(uint64_t this_ptr, uint64_t val) {
37313 LDKMessageHandler this_ptr_conv;
37314 this_ptr_conv.inner = untag_ptr(this_ptr);
37315 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37317 this_ptr_conv.is_owned = false;
37318 void* val_ptr = untag_ptr(val);
37319 CHECK_ACCESS(val_ptr);
37320 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
37321 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
37322 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37323 LDKChannelMessageHandler_JCalls_cloned(&val_conv);
37325 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
37328 uint64_t __attribute__((export_name("TS_MessageHandler_get_route_handler"))) TS_MessageHandler_get_route_handler(uint64_t this_ptr) {
37329 LDKMessageHandler this_ptr_conv;
37330 this_ptr_conv.inner = untag_ptr(this_ptr);
37331 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37332 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37333 this_ptr_conv.is_owned = false;
37334 // WARNING: This object doesn't live past this scope, needs clone!
37335 uint64_t ret_ret = tag_ptr(MessageHandler_get_route_handler(&this_ptr_conv), false);
37339 void __attribute__((export_name("TS_MessageHandler_set_route_handler"))) TS_MessageHandler_set_route_handler(uint64_t this_ptr, uint64_t val) {
37340 LDKMessageHandler this_ptr_conv;
37341 this_ptr_conv.inner = untag_ptr(this_ptr);
37342 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37344 this_ptr_conv.is_owned = false;
37345 void* val_ptr = untag_ptr(val);
37346 CHECK_ACCESS(val_ptr);
37347 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
37348 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
37349 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37350 LDKRoutingMessageHandler_JCalls_cloned(&val_conv);
37352 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
37355 uint64_t __attribute__((export_name("TS_MessageHandler_get_onion_message_handler"))) TS_MessageHandler_get_onion_message_handler(uint64_t this_ptr) {
37356 LDKMessageHandler this_ptr_conv;
37357 this_ptr_conv.inner = untag_ptr(this_ptr);
37358 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37359 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37360 this_ptr_conv.is_owned = false;
37361 // WARNING: This object doesn't live past this scope, needs clone!
37362 uint64_t ret_ret = tag_ptr(MessageHandler_get_onion_message_handler(&this_ptr_conv), false);
37366 void __attribute__((export_name("TS_MessageHandler_set_onion_message_handler"))) TS_MessageHandler_set_onion_message_handler(uint64_t this_ptr, uint64_t val) {
37367 LDKMessageHandler this_ptr_conv;
37368 this_ptr_conv.inner = untag_ptr(this_ptr);
37369 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37371 this_ptr_conv.is_owned = false;
37372 void* val_ptr = untag_ptr(val);
37373 CHECK_ACCESS(val_ptr);
37374 LDKOnionMessageHandler val_conv = *(LDKOnionMessageHandler*)(val_ptr);
37375 if (val_conv.free == LDKOnionMessageHandler_JCalls_free) {
37376 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37377 LDKOnionMessageHandler_JCalls_cloned(&val_conv);
37379 MessageHandler_set_onion_message_handler(&this_ptr_conv, val_conv);
37382 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) {
37383 void* chan_handler_arg_ptr = untag_ptr(chan_handler_arg);
37384 CHECK_ACCESS(chan_handler_arg_ptr);
37385 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(chan_handler_arg_ptr);
37386 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
37387 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37388 LDKChannelMessageHandler_JCalls_cloned(&chan_handler_arg_conv);
37390 void* route_handler_arg_ptr = untag_ptr(route_handler_arg);
37391 CHECK_ACCESS(route_handler_arg_ptr);
37392 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(route_handler_arg_ptr);
37393 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
37394 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37395 LDKRoutingMessageHandler_JCalls_cloned(&route_handler_arg_conv);
37397 void* onion_message_handler_arg_ptr = untag_ptr(onion_message_handler_arg);
37398 CHECK_ACCESS(onion_message_handler_arg_ptr);
37399 LDKOnionMessageHandler onion_message_handler_arg_conv = *(LDKOnionMessageHandler*)(onion_message_handler_arg_ptr);
37400 if (onion_message_handler_arg_conv.free == LDKOnionMessageHandler_JCalls_free) {
37401 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37402 LDKOnionMessageHandler_JCalls_cloned(&onion_message_handler_arg_conv);
37404 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv, onion_message_handler_arg_conv);
37405 uint64_t ret_ref = 0;
37406 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37407 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37411 static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
37412 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
37413 *ret_ret = SocketDescriptor_clone(arg);
37414 return tag_ptr(ret_ret, true);
37416 int64_t __attribute__((export_name("TS_SocketDescriptor_clone_ptr"))) TS_SocketDescriptor_clone_ptr(uint64_t arg) {
37417 void* arg_ptr = untag_ptr(arg);
37418 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
37419 LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
37420 int64_t ret_conv = SocketDescriptor_clone_ptr(arg_conv);
37424 uint64_t __attribute__((export_name("TS_SocketDescriptor_clone"))) TS_SocketDescriptor_clone(uint64_t orig) {
37425 void* orig_ptr = untag_ptr(orig);
37426 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
37427 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)orig_ptr;
37428 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
37429 *ret_ret = SocketDescriptor_clone(orig_conv);
37430 return tag_ptr(ret_ret, true);
37433 void __attribute__((export_name("TS_SocketDescriptor_free"))) TS_SocketDescriptor_free(uint64_t this_ptr) {
37434 if (!ptr_is_owned(this_ptr)) return;
37435 void* this_ptr_ptr = untag_ptr(this_ptr);
37436 CHECK_ACCESS(this_ptr_ptr);
37437 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(this_ptr_ptr);
37438 FREE(untag_ptr(this_ptr));
37439 SocketDescriptor_free(this_ptr_conv);
37442 void __attribute__((export_name("TS_PeerHandleError_free"))) TS_PeerHandleError_free(uint64_t this_obj) {
37443 LDKPeerHandleError this_obj_conv;
37444 this_obj_conv.inner = untag_ptr(this_obj);
37445 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37447 PeerHandleError_free(this_obj_conv);
37450 uint64_t __attribute__((export_name("TS_PeerHandleError_new"))) TS_PeerHandleError_new() {
37451 LDKPeerHandleError ret_var = PeerHandleError_new();
37452 uint64_t ret_ref = 0;
37453 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37454 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37458 static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
37459 LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
37460 uint64_t ret_ref = 0;
37461 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37462 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37465 int64_t __attribute__((export_name("TS_PeerHandleError_clone_ptr"))) TS_PeerHandleError_clone_ptr(uint64_t arg) {
37466 LDKPeerHandleError arg_conv;
37467 arg_conv.inner = untag_ptr(arg);
37468 arg_conv.is_owned = ptr_is_owned(arg);
37469 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37470 arg_conv.is_owned = false;
37471 int64_t ret_conv = PeerHandleError_clone_ptr(&arg_conv);
37475 uint64_t __attribute__((export_name("TS_PeerHandleError_clone"))) TS_PeerHandleError_clone(uint64_t orig) {
37476 LDKPeerHandleError orig_conv;
37477 orig_conv.inner = untag_ptr(orig);
37478 orig_conv.is_owned = ptr_is_owned(orig);
37479 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37480 orig_conv.is_owned = false;
37481 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
37482 uint64_t ret_ref = 0;
37483 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37484 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37488 void __attribute__((export_name("TS_PeerManager_free"))) TS_PeerManager_free(uint64_t this_obj) {
37489 LDKPeerManager this_obj_conv;
37490 this_obj_conv.inner = untag_ptr(this_obj);
37491 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37493 PeerManager_free(this_obj_conv);
37496 uint64_t __attribute__((export_name("TS_PeerManager_new"))) TS_PeerManager_new(uint64_t message_handler, int32_t current_time, int8_tArray ephemeral_random_data, uint64_t logger, uint64_t custom_message_handler, uint64_t node_signer) {
37497 LDKMessageHandler message_handler_conv;
37498 message_handler_conv.inner = untag_ptr(message_handler);
37499 message_handler_conv.is_owned = ptr_is_owned(message_handler);
37500 CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
37501 // WARNING: we need a move here but no clone is available for LDKMessageHandler
37503 uint8_t ephemeral_random_data_arr[32];
37504 CHECK(ephemeral_random_data->arr_len == 32);
37505 memcpy(ephemeral_random_data_arr, ephemeral_random_data->elems, 32); FREE(ephemeral_random_data);
37506 uint8_t (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
37507 void* logger_ptr = untag_ptr(logger);
37508 CHECK_ACCESS(logger_ptr);
37509 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
37510 if (logger_conv.free == LDKLogger_JCalls_free) {
37511 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37512 LDKLogger_JCalls_cloned(&logger_conv);
37514 void* custom_message_handler_ptr = untag_ptr(custom_message_handler);
37515 CHECK_ACCESS(custom_message_handler_ptr);
37516 LDKCustomMessageHandler custom_message_handler_conv = *(LDKCustomMessageHandler*)(custom_message_handler_ptr);
37517 if (custom_message_handler_conv.free == LDKCustomMessageHandler_JCalls_free) {
37518 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37519 LDKCustomMessageHandler_JCalls_cloned(&custom_message_handler_conv);
37521 void* node_signer_ptr = untag_ptr(node_signer);
37522 CHECK_ACCESS(node_signer_ptr);
37523 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
37524 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
37525 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37526 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
37528 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, current_time, ephemeral_random_data_ref, logger_conv, custom_message_handler_conv, node_signer_conv);
37529 uint64_t ret_ref = 0;
37530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37531 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37535 uint64_tArray __attribute__((export_name("TS_PeerManager_get_peer_node_ids"))) TS_PeerManager_get_peer_node_ids(uint64_t this_arg) {
37536 LDKPeerManager this_arg_conv;
37537 this_arg_conv.inner = untag_ptr(this_arg);
37538 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37540 this_arg_conv.is_owned = false;
37541 LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
37542 uint64_tArray ret_arr = NULL;
37543 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
37544 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
37545 for (size_t o = 0; o < ret_var.datalen; o++) {
37546 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
37547 *ret_conv_40_conv = ret_var.data[o];
37548 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
37551 FREE(ret_var.data);
37555 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) {
37556 LDKPeerManager this_arg_conv;
37557 this_arg_conv.inner = untag_ptr(this_arg);
37558 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37560 this_arg_conv.is_owned = false;
37561 LDKPublicKey their_node_id_ref;
37562 CHECK(their_node_id->arr_len == 33);
37563 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
37564 void* descriptor_ptr = untag_ptr(descriptor);
37565 CHECK_ACCESS(descriptor_ptr);
37566 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
37567 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
37568 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37569 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
37571 void* remote_network_address_ptr = untag_ptr(remote_network_address);
37572 CHECK_ACCESS(remote_network_address_ptr);
37573 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
37574 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
37575 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv, remote_network_address_conv);
37576 return tag_ptr(ret_conv, true);
37579 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) {
37580 LDKPeerManager this_arg_conv;
37581 this_arg_conv.inner = untag_ptr(this_arg);
37582 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37584 this_arg_conv.is_owned = false;
37585 void* descriptor_ptr = untag_ptr(descriptor);
37586 CHECK_ACCESS(descriptor_ptr);
37587 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
37588 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
37589 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37590 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
37592 void* remote_network_address_ptr = untag_ptr(remote_network_address);
37593 CHECK_ACCESS(remote_network_address_ptr);
37594 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
37595 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
37596 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv, remote_network_address_conv);
37597 return tag_ptr(ret_conv, true);
37600 uint64_t __attribute__((export_name("TS_PeerManager_write_buffer_space_avail"))) TS_PeerManager_write_buffer_space_avail(uint64_t this_arg, uint64_t descriptor) {
37601 LDKPeerManager this_arg_conv;
37602 this_arg_conv.inner = untag_ptr(this_arg);
37603 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37605 this_arg_conv.is_owned = false;
37606 void* descriptor_ptr = untag_ptr(descriptor);
37607 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
37608 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
37609 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
37610 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
37611 return tag_ptr(ret_conv, true);
37614 uint64_t __attribute__((export_name("TS_PeerManager_read_event"))) TS_PeerManager_read_event(uint64_t this_arg, uint64_t peer_descriptor, int8_tArray data) {
37615 LDKPeerManager this_arg_conv;
37616 this_arg_conv.inner = untag_ptr(this_arg);
37617 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37618 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37619 this_arg_conv.is_owned = false;
37620 void* peer_descriptor_ptr = untag_ptr(peer_descriptor);
37621 if (ptr_is_owned(peer_descriptor)) { CHECK_ACCESS(peer_descriptor_ptr); }
37622 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
37623 LDKu8slice data_ref;
37624 data_ref.datalen = data->arr_len;
37625 data_ref.data = data->elems;
37626 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
37627 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
37629 return tag_ptr(ret_conv, true);
37632 void __attribute__((export_name("TS_PeerManager_process_events"))) TS_PeerManager_process_events(uint64_t this_arg) {
37633 LDKPeerManager this_arg_conv;
37634 this_arg_conv.inner = untag_ptr(this_arg);
37635 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37636 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37637 this_arg_conv.is_owned = false;
37638 PeerManager_process_events(&this_arg_conv);
37641 void __attribute__((export_name("TS_PeerManager_socket_disconnected"))) TS_PeerManager_socket_disconnected(uint64_t this_arg, uint64_t descriptor) {
37642 LDKPeerManager this_arg_conv;
37643 this_arg_conv.inner = untag_ptr(this_arg);
37644 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37645 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37646 this_arg_conv.is_owned = false;
37647 void* descriptor_ptr = untag_ptr(descriptor);
37648 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
37649 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
37650 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
37653 void __attribute__((export_name("TS_PeerManager_disconnect_by_node_id"))) TS_PeerManager_disconnect_by_node_id(uint64_t this_arg, int8_tArray node_id) {
37654 LDKPeerManager this_arg_conv;
37655 this_arg_conv.inner = untag_ptr(this_arg);
37656 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37658 this_arg_conv.is_owned = false;
37659 LDKPublicKey node_id_ref;
37660 CHECK(node_id->arr_len == 33);
37661 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
37662 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref);
37665 void __attribute__((export_name("TS_PeerManager_disconnect_all_peers"))) TS_PeerManager_disconnect_all_peers(uint64_t this_arg) {
37666 LDKPeerManager this_arg_conv;
37667 this_arg_conv.inner = untag_ptr(this_arg);
37668 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37670 this_arg_conv.is_owned = false;
37671 PeerManager_disconnect_all_peers(&this_arg_conv);
37674 void __attribute__((export_name("TS_PeerManager_timer_tick_occurred"))) TS_PeerManager_timer_tick_occurred(uint64_t this_arg) {
37675 LDKPeerManager this_arg_conv;
37676 this_arg_conv.inner = untag_ptr(this_arg);
37677 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37678 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37679 this_arg_conv.is_owned = false;
37680 PeerManager_timer_tick_occurred(&this_arg_conv);
37683 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) {
37684 LDKPeerManager this_arg_conv;
37685 this_arg_conv.inner = untag_ptr(this_arg);
37686 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37687 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37688 this_arg_conv.is_owned = false;
37689 LDKThreeBytes rgb_ref;
37690 CHECK(rgb->arr_len == 3);
37691 memcpy(rgb_ref.data, rgb->elems, 3); FREE(rgb);
37692 LDKThirtyTwoBytes alias_ref;
37693 CHECK(alias->arr_len == 32);
37694 memcpy(alias_ref.data, alias->elems, 32); FREE(alias);
37695 LDKCVec_NetAddressZ addresses_constr;
37696 addresses_constr.datalen = addresses->arr_len;
37697 if (addresses_constr.datalen > 0)
37698 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
37700 addresses_constr.data = NULL;
37701 uint64_t* addresses_vals = addresses->elems;
37702 for (size_t m = 0; m < addresses_constr.datalen; m++) {
37703 uint64_t addresses_conv_12 = addresses_vals[m];
37704 void* addresses_conv_12_ptr = untag_ptr(addresses_conv_12);
37705 CHECK_ACCESS(addresses_conv_12_ptr);
37706 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(addresses_conv_12_ptr);
37707 addresses_constr.data[m] = addresses_conv_12_conv;
37710 PeerManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
37713 int64_t __attribute__((export_name("TS_htlc_success_tx_weight"))) TS_htlc_success_tx_weight(jboolean opt_anchors) {
37714 int64_t ret_conv = htlc_success_tx_weight(opt_anchors);
37718 int64_t __attribute__((export_name("TS_htlc_timeout_tx_weight"))) TS_htlc_timeout_tx_weight(jboolean opt_anchors) {
37719 int64_t ret_conv = htlc_timeout_tx_weight(opt_anchors);
37723 uint32_t __attribute__((export_name("TS_HTLCClaim_clone"))) TS_HTLCClaim_clone(uint64_t orig) {
37724 LDKHTLCClaim* orig_conv = (LDKHTLCClaim*)untag_ptr(orig);
37725 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_clone(orig_conv));
37729 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_timeout"))) TS_HTLCClaim_offered_timeout() {
37730 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_timeout());
37734 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_preimage"))) TS_HTLCClaim_offered_preimage() {
37735 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_preimage());
37739 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_timeout"))) TS_HTLCClaim_accepted_timeout() {
37740 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_timeout());
37744 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_preimage"))) TS_HTLCClaim_accepted_preimage() {
37745 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_preimage());
37749 uint32_t __attribute__((export_name("TS_HTLCClaim_revocation"))) TS_HTLCClaim_revocation() {
37750 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_revocation());
37754 jboolean __attribute__((export_name("TS_HTLCClaim_eq"))) TS_HTLCClaim_eq(uint64_t a, uint64_t b) {
37755 LDKHTLCClaim* a_conv = (LDKHTLCClaim*)untag_ptr(a);
37756 LDKHTLCClaim* b_conv = (LDKHTLCClaim*)untag_ptr(b);
37757 jboolean ret_conv = HTLCClaim_eq(a_conv, b_conv);
37761 uint64_t __attribute__((export_name("TS_HTLCClaim_from_witness"))) TS_HTLCClaim_from_witness(int8_tArray witness) {
37762 LDKWitness witness_ref;
37763 witness_ref.datalen = witness->arr_len;
37764 witness_ref.data = MALLOC(witness_ref.datalen, "LDKWitness Bytes");
37765 memcpy(witness_ref.data, witness->elems, witness_ref.datalen); FREE(witness);
37766 witness_ref.data_is_owned = true;
37767 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
37768 *ret_copy = HTLCClaim_from_witness(witness_ref);
37769 uint64_t ret_ref = tag_ptr(ret_copy, true);
37773 int8_tArray __attribute__((export_name("TS_build_commitment_secret"))) TS_build_commitment_secret(int8_tArray commitment_seed, int64_t idx) {
37774 uint8_t commitment_seed_arr[32];
37775 CHECK(commitment_seed->arr_len == 32);
37776 memcpy(commitment_seed_arr, commitment_seed->elems, 32); FREE(commitment_seed);
37777 uint8_t (*commitment_seed_ref)[32] = &commitment_seed_arr;
37778 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37779 memcpy(ret_arr->elems, build_commitment_secret(commitment_seed_ref, idx).data, 32);
37783 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) {
37784 LDKCVec_u8Z to_holder_script_ref;
37785 to_holder_script_ref.datalen = to_holder_script->arr_len;
37786 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
37787 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
37788 LDKCVec_u8Z to_counterparty_script_ref;
37789 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
37790 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
37791 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
37792 LDKOutPoint funding_outpoint_conv;
37793 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
37794 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
37795 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
37796 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
37797 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);
37798 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37799 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37800 Transaction_free(ret_var);
37804 void __attribute__((export_name("TS_CounterpartyCommitmentSecrets_free"))) TS_CounterpartyCommitmentSecrets_free(uint64_t this_obj) {
37805 LDKCounterpartyCommitmentSecrets this_obj_conv;
37806 this_obj_conv.inner = untag_ptr(this_obj);
37807 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37809 CounterpartyCommitmentSecrets_free(this_obj_conv);
37812 static inline uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg) {
37813 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(arg);
37814 uint64_t ret_ref = 0;
37815 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37816 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37819 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone_ptr"))) TS_CounterpartyCommitmentSecrets_clone_ptr(uint64_t arg) {
37820 LDKCounterpartyCommitmentSecrets arg_conv;
37821 arg_conv.inner = untag_ptr(arg);
37822 arg_conv.is_owned = ptr_is_owned(arg);
37823 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37824 arg_conv.is_owned = false;
37825 int64_t ret_conv = CounterpartyCommitmentSecrets_clone_ptr(&arg_conv);
37829 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone"))) TS_CounterpartyCommitmentSecrets_clone(uint64_t orig) {
37830 LDKCounterpartyCommitmentSecrets orig_conv;
37831 orig_conv.inner = untag_ptr(orig);
37832 orig_conv.is_owned = ptr_is_owned(orig);
37833 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37834 orig_conv.is_owned = false;
37835 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(&orig_conv);
37836 uint64_t ret_ref = 0;
37837 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37838 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37842 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_new"))) TS_CounterpartyCommitmentSecrets_new() {
37843 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_new();
37844 uint64_t ret_ref = 0;
37845 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37846 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37850 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_min_seen_secret"))) TS_CounterpartyCommitmentSecrets_get_min_seen_secret(uint64_t this_arg) {
37851 LDKCounterpartyCommitmentSecrets this_arg_conv;
37852 this_arg_conv.inner = untag_ptr(this_arg);
37853 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37854 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37855 this_arg_conv.is_owned = false;
37856 int64_t ret_conv = CounterpartyCommitmentSecrets_get_min_seen_secret(&this_arg_conv);
37860 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_provide_secret"))) TS_CounterpartyCommitmentSecrets_provide_secret(uint64_t this_arg, int64_t idx, int8_tArray secret) {
37861 LDKCounterpartyCommitmentSecrets this_arg_conv;
37862 this_arg_conv.inner = untag_ptr(this_arg);
37863 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37865 this_arg_conv.is_owned = false;
37866 LDKThirtyTwoBytes secret_ref;
37867 CHECK(secret->arr_len == 32);
37868 memcpy(secret_ref.data, secret->elems, 32); FREE(secret);
37869 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
37870 *ret_conv = CounterpartyCommitmentSecrets_provide_secret(&this_arg_conv, idx, secret_ref);
37871 return tag_ptr(ret_conv, true);
37874 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_secret"))) TS_CounterpartyCommitmentSecrets_get_secret(uint64_t this_arg, int64_t idx) {
37875 LDKCounterpartyCommitmentSecrets this_arg_conv;
37876 this_arg_conv.inner = untag_ptr(this_arg);
37877 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37879 this_arg_conv.is_owned = false;
37880 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37881 memcpy(ret_arr->elems, CounterpartyCommitmentSecrets_get_secret(&this_arg_conv, idx).data, 32);
37885 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_write"))) TS_CounterpartyCommitmentSecrets_write(uint64_t obj) {
37886 LDKCounterpartyCommitmentSecrets obj_conv;
37887 obj_conv.inner = untag_ptr(obj);
37888 obj_conv.is_owned = ptr_is_owned(obj);
37889 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37890 obj_conv.is_owned = false;
37891 LDKCVec_u8Z ret_var = CounterpartyCommitmentSecrets_write(&obj_conv);
37892 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37893 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37894 CVec_u8Z_free(ret_var);
37898 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_read"))) TS_CounterpartyCommitmentSecrets_read(int8_tArray ser) {
37899 LDKu8slice ser_ref;
37900 ser_ref.datalen = ser->arr_len;
37901 ser_ref.data = ser->elems;
37902 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
37903 *ret_conv = CounterpartyCommitmentSecrets_read(ser_ref);
37905 return tag_ptr(ret_conv, true);
37908 int8_tArray __attribute__((export_name("TS_derive_private_key"))) TS_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) {
37909 LDKPublicKey per_commitment_point_ref;
37910 CHECK(per_commitment_point->arr_len == 33);
37911 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37912 uint8_t base_secret_arr[32];
37913 CHECK(base_secret->arr_len == 32);
37914 memcpy(base_secret_arr, base_secret->elems, 32); FREE(base_secret);
37915 uint8_t (*base_secret_ref)[32] = &base_secret_arr;
37916 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37917 memcpy(ret_arr->elems, derive_private_key(per_commitment_point_ref, base_secret_ref).bytes, 32);
37921 int8_tArray __attribute__((export_name("TS_derive_public_key"))) TS_derive_public_key(int8_tArray per_commitment_point, int8_tArray base_point) {
37922 LDKPublicKey per_commitment_point_ref;
37923 CHECK(per_commitment_point->arr_len == 33);
37924 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37925 LDKPublicKey base_point_ref;
37926 CHECK(base_point->arr_len == 33);
37927 memcpy(base_point_ref.compressed_form, base_point->elems, 33); FREE(base_point);
37928 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37929 memcpy(ret_arr->elems, derive_public_key(per_commitment_point_ref, base_point_ref).compressed_form, 33);
37933 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) {
37934 uint8_t per_commitment_secret_arr[32];
37935 CHECK(per_commitment_secret->arr_len == 32);
37936 memcpy(per_commitment_secret_arr, per_commitment_secret->elems, 32); FREE(per_commitment_secret);
37937 uint8_t (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
37938 uint8_t countersignatory_revocation_base_secret_arr[32];
37939 CHECK(countersignatory_revocation_base_secret->arr_len == 32);
37940 memcpy(countersignatory_revocation_base_secret_arr, countersignatory_revocation_base_secret->elems, 32); FREE(countersignatory_revocation_base_secret);
37941 uint8_t (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
37942 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37943 memcpy(ret_arr->elems, derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref).bytes, 32);
37947 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) {
37948 LDKPublicKey per_commitment_point_ref;
37949 CHECK(per_commitment_point->arr_len == 33);
37950 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37951 LDKPublicKey countersignatory_revocation_base_point_ref;
37952 CHECK(countersignatory_revocation_base_point->arr_len == 33);
37953 memcpy(countersignatory_revocation_base_point_ref.compressed_form, countersignatory_revocation_base_point->elems, 33); FREE(countersignatory_revocation_base_point);
37954 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37955 memcpy(ret_arr->elems, derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref).compressed_form, 33);
37959 void __attribute__((export_name("TS_TxCreationKeys_free"))) TS_TxCreationKeys_free(uint64_t this_obj) {
37960 LDKTxCreationKeys this_obj_conv;
37961 this_obj_conv.inner = untag_ptr(this_obj);
37962 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37964 TxCreationKeys_free(this_obj_conv);
37967 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_per_commitment_point"))) TS_TxCreationKeys_get_per_commitment_point(uint64_t this_ptr) {
37968 LDKTxCreationKeys this_ptr_conv;
37969 this_ptr_conv.inner = untag_ptr(this_ptr);
37970 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37972 this_ptr_conv.is_owned = false;
37973 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37974 memcpy(ret_arr->elems, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
37978 void __attribute__((export_name("TS_TxCreationKeys_set_per_commitment_point"))) TS_TxCreationKeys_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
37979 LDKTxCreationKeys this_ptr_conv;
37980 this_ptr_conv.inner = untag_ptr(this_ptr);
37981 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37983 this_ptr_conv.is_owned = false;
37984 LDKPublicKey val_ref;
37985 CHECK(val->arr_len == 33);
37986 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37987 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
37990 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_revocation_key"))) TS_TxCreationKeys_get_revocation_key(uint64_t this_ptr) {
37991 LDKTxCreationKeys this_ptr_conv;
37992 this_ptr_conv.inner = untag_ptr(this_ptr);
37993 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37995 this_ptr_conv.is_owned = false;
37996 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37997 memcpy(ret_arr->elems, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
38001 void __attribute__((export_name("TS_TxCreationKeys_set_revocation_key"))) TS_TxCreationKeys_set_revocation_key(uint64_t this_ptr, int8_tArray val) {
38002 LDKTxCreationKeys this_ptr_conv;
38003 this_ptr_conv.inner = untag_ptr(this_ptr);
38004 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38006 this_ptr_conv.is_owned = false;
38007 LDKPublicKey val_ref;
38008 CHECK(val->arr_len == 33);
38009 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38010 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
38013 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_htlc_key"))) TS_TxCreationKeys_get_broadcaster_htlc_key(uint64_t this_ptr) {
38014 LDKTxCreationKeys this_ptr_conv;
38015 this_ptr_conv.inner = untag_ptr(this_ptr);
38016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38018 this_ptr_conv.is_owned = false;
38019 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38020 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
38024 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_htlc_key"))) TS_TxCreationKeys_set_broadcaster_htlc_key(uint64_t this_ptr, int8_tArray val) {
38025 LDKTxCreationKeys this_ptr_conv;
38026 this_ptr_conv.inner = untag_ptr(this_ptr);
38027 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38028 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38029 this_ptr_conv.is_owned = false;
38030 LDKPublicKey val_ref;
38031 CHECK(val->arr_len == 33);
38032 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38033 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
38036 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_countersignatory_htlc_key"))) TS_TxCreationKeys_get_countersignatory_htlc_key(uint64_t this_ptr) {
38037 LDKTxCreationKeys this_ptr_conv;
38038 this_ptr_conv.inner = untag_ptr(this_ptr);
38039 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38040 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38041 this_ptr_conv.is_owned = false;
38042 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38043 memcpy(ret_arr->elems, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
38047 void __attribute__((export_name("TS_TxCreationKeys_set_countersignatory_htlc_key"))) TS_TxCreationKeys_set_countersignatory_htlc_key(uint64_t this_ptr, int8_tArray val) {
38048 LDKTxCreationKeys this_ptr_conv;
38049 this_ptr_conv.inner = untag_ptr(this_ptr);
38050 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38052 this_ptr_conv.is_owned = false;
38053 LDKPublicKey val_ref;
38054 CHECK(val->arr_len == 33);
38055 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38056 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
38059 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_get_broadcaster_delayed_payment_key(uint64_t this_ptr) {
38060 LDKTxCreationKeys this_ptr_conv;
38061 this_ptr_conv.inner = untag_ptr(this_ptr);
38062 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38063 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38064 this_ptr_conv.is_owned = false;
38065 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38066 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
38070 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) {
38071 LDKTxCreationKeys this_ptr_conv;
38072 this_ptr_conv.inner = untag_ptr(this_ptr);
38073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38075 this_ptr_conv.is_owned = false;
38076 LDKPublicKey val_ref;
38077 CHECK(val->arr_len == 33);
38078 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38079 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
38082 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) {
38083 LDKPublicKey per_commitment_point_arg_ref;
38084 CHECK(per_commitment_point_arg->arr_len == 33);
38085 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
38086 LDKPublicKey revocation_key_arg_ref;
38087 CHECK(revocation_key_arg->arr_len == 33);
38088 memcpy(revocation_key_arg_ref.compressed_form, revocation_key_arg->elems, 33); FREE(revocation_key_arg);
38089 LDKPublicKey broadcaster_htlc_key_arg_ref;
38090 CHECK(broadcaster_htlc_key_arg->arr_len == 33);
38091 memcpy(broadcaster_htlc_key_arg_ref.compressed_form, broadcaster_htlc_key_arg->elems, 33); FREE(broadcaster_htlc_key_arg);
38092 LDKPublicKey countersignatory_htlc_key_arg_ref;
38093 CHECK(countersignatory_htlc_key_arg->arr_len == 33);
38094 memcpy(countersignatory_htlc_key_arg_ref.compressed_form, countersignatory_htlc_key_arg->elems, 33); FREE(countersignatory_htlc_key_arg);
38095 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
38096 CHECK(broadcaster_delayed_payment_key_arg->arr_len == 33);
38097 memcpy(broadcaster_delayed_payment_key_arg_ref.compressed_form, broadcaster_delayed_payment_key_arg->elems, 33); FREE(broadcaster_delayed_payment_key_arg);
38098 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);
38099 uint64_t ret_ref = 0;
38100 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38101 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38105 jboolean __attribute__((export_name("TS_TxCreationKeys_eq"))) TS_TxCreationKeys_eq(uint64_t a, uint64_t b) {
38106 LDKTxCreationKeys a_conv;
38107 a_conv.inner = untag_ptr(a);
38108 a_conv.is_owned = ptr_is_owned(a);
38109 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38110 a_conv.is_owned = false;
38111 LDKTxCreationKeys b_conv;
38112 b_conv.inner = untag_ptr(b);
38113 b_conv.is_owned = ptr_is_owned(b);
38114 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38115 b_conv.is_owned = false;
38116 jboolean ret_conv = TxCreationKeys_eq(&a_conv, &b_conv);
38120 static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
38121 LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
38122 uint64_t ret_ref = 0;
38123 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38124 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38127 int64_t __attribute__((export_name("TS_TxCreationKeys_clone_ptr"))) TS_TxCreationKeys_clone_ptr(uint64_t arg) {
38128 LDKTxCreationKeys arg_conv;
38129 arg_conv.inner = untag_ptr(arg);
38130 arg_conv.is_owned = ptr_is_owned(arg);
38131 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38132 arg_conv.is_owned = false;
38133 int64_t ret_conv = TxCreationKeys_clone_ptr(&arg_conv);
38137 uint64_t __attribute__((export_name("TS_TxCreationKeys_clone"))) TS_TxCreationKeys_clone(uint64_t orig) {
38138 LDKTxCreationKeys orig_conv;
38139 orig_conv.inner = untag_ptr(orig);
38140 orig_conv.is_owned = ptr_is_owned(orig);
38141 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38142 orig_conv.is_owned = false;
38143 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_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 int8_tArray __attribute__((export_name("TS_TxCreationKeys_write"))) TS_TxCreationKeys_write(uint64_t obj) {
38151 LDKTxCreationKeys obj_conv;
38152 obj_conv.inner = untag_ptr(obj);
38153 obj_conv.is_owned = ptr_is_owned(obj);
38154 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38155 obj_conv.is_owned = false;
38156 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
38157 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38158 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38159 CVec_u8Z_free(ret_var);
38163 uint64_t __attribute__((export_name("TS_TxCreationKeys_read"))) TS_TxCreationKeys_read(int8_tArray ser) {
38164 LDKu8slice ser_ref;
38165 ser_ref.datalen = ser->arr_len;
38166 ser_ref.data = ser->elems;
38167 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
38168 *ret_conv = TxCreationKeys_read(ser_ref);
38170 return tag_ptr(ret_conv, true);
38173 void __attribute__((export_name("TS_ChannelPublicKeys_free"))) TS_ChannelPublicKeys_free(uint64_t this_obj) {
38174 LDKChannelPublicKeys this_obj_conv;
38175 this_obj_conv.inner = untag_ptr(this_obj);
38176 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38177 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38178 ChannelPublicKeys_free(this_obj_conv);
38181 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_funding_pubkey"))) TS_ChannelPublicKeys_get_funding_pubkey(uint64_t this_ptr) {
38182 LDKChannelPublicKeys this_ptr_conv;
38183 this_ptr_conv.inner = untag_ptr(this_ptr);
38184 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38186 this_ptr_conv.is_owned = false;
38187 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38188 memcpy(ret_arr->elems, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
38192 void __attribute__((export_name("TS_ChannelPublicKeys_set_funding_pubkey"))) TS_ChannelPublicKeys_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
38193 LDKChannelPublicKeys this_ptr_conv;
38194 this_ptr_conv.inner = untag_ptr(this_ptr);
38195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38197 this_ptr_conv.is_owned = false;
38198 LDKPublicKey val_ref;
38199 CHECK(val->arr_len == 33);
38200 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38201 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
38204 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_revocation_basepoint"))) TS_ChannelPublicKeys_get_revocation_basepoint(uint64_t this_ptr) {
38205 LDKChannelPublicKeys this_ptr_conv;
38206 this_ptr_conv.inner = untag_ptr(this_ptr);
38207 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38209 this_ptr_conv.is_owned = false;
38210 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38211 memcpy(ret_arr->elems, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
38215 void __attribute__((export_name("TS_ChannelPublicKeys_set_revocation_basepoint"))) TS_ChannelPublicKeys_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
38216 LDKChannelPublicKeys this_ptr_conv;
38217 this_ptr_conv.inner = untag_ptr(this_ptr);
38218 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38220 this_ptr_conv.is_owned = false;
38221 LDKPublicKey val_ref;
38222 CHECK(val->arr_len == 33);
38223 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38224 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
38227 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_payment_point"))) TS_ChannelPublicKeys_get_payment_point(uint64_t this_ptr) {
38228 LDKChannelPublicKeys this_ptr_conv;
38229 this_ptr_conv.inner = untag_ptr(this_ptr);
38230 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38231 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38232 this_ptr_conv.is_owned = false;
38233 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38234 memcpy(ret_arr->elems, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
38238 void __attribute__((export_name("TS_ChannelPublicKeys_set_payment_point"))) TS_ChannelPublicKeys_set_payment_point(uint64_t this_ptr, int8_tArray val) {
38239 LDKChannelPublicKeys this_ptr_conv;
38240 this_ptr_conv.inner = untag_ptr(this_ptr);
38241 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38243 this_ptr_conv.is_owned = false;
38244 LDKPublicKey val_ref;
38245 CHECK(val->arr_len == 33);
38246 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38247 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
38250 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_delayed_payment_basepoint"))) TS_ChannelPublicKeys_get_delayed_payment_basepoint(uint64_t this_ptr) {
38251 LDKChannelPublicKeys this_ptr_conv;
38252 this_ptr_conv.inner = untag_ptr(this_ptr);
38253 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38254 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38255 this_ptr_conv.is_owned = false;
38256 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38257 memcpy(ret_arr->elems, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
38261 void __attribute__((export_name("TS_ChannelPublicKeys_set_delayed_payment_basepoint"))) TS_ChannelPublicKeys_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
38262 LDKChannelPublicKeys this_ptr_conv;
38263 this_ptr_conv.inner = untag_ptr(this_ptr);
38264 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38266 this_ptr_conv.is_owned = false;
38267 LDKPublicKey val_ref;
38268 CHECK(val->arr_len == 33);
38269 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38270 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
38273 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_htlc_basepoint"))) TS_ChannelPublicKeys_get_htlc_basepoint(uint64_t this_ptr) {
38274 LDKChannelPublicKeys this_ptr_conv;
38275 this_ptr_conv.inner = untag_ptr(this_ptr);
38276 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38278 this_ptr_conv.is_owned = false;
38279 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38280 memcpy(ret_arr->elems, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
38284 void __attribute__((export_name("TS_ChannelPublicKeys_set_htlc_basepoint"))) TS_ChannelPublicKeys_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
38285 LDKChannelPublicKeys this_ptr_conv;
38286 this_ptr_conv.inner = untag_ptr(this_ptr);
38287 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38289 this_ptr_conv.is_owned = false;
38290 LDKPublicKey val_ref;
38291 CHECK(val->arr_len == 33);
38292 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38293 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
38296 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) {
38297 LDKPublicKey funding_pubkey_arg_ref;
38298 CHECK(funding_pubkey_arg->arr_len == 33);
38299 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
38300 LDKPublicKey revocation_basepoint_arg_ref;
38301 CHECK(revocation_basepoint_arg->arr_len == 33);
38302 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
38303 LDKPublicKey payment_point_arg_ref;
38304 CHECK(payment_point_arg->arr_len == 33);
38305 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
38306 LDKPublicKey delayed_payment_basepoint_arg_ref;
38307 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
38308 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
38309 LDKPublicKey htlc_basepoint_arg_ref;
38310 CHECK(htlc_basepoint_arg->arr_len == 33);
38311 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
38312 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);
38313 uint64_t ret_ref = 0;
38314 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38315 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38319 static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
38320 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
38321 uint64_t ret_ref = 0;
38322 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38323 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38326 int64_t __attribute__((export_name("TS_ChannelPublicKeys_clone_ptr"))) TS_ChannelPublicKeys_clone_ptr(uint64_t arg) {
38327 LDKChannelPublicKeys arg_conv;
38328 arg_conv.inner = untag_ptr(arg);
38329 arg_conv.is_owned = ptr_is_owned(arg);
38330 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38331 arg_conv.is_owned = false;
38332 int64_t ret_conv = ChannelPublicKeys_clone_ptr(&arg_conv);
38336 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_clone"))) TS_ChannelPublicKeys_clone(uint64_t orig) {
38337 LDKChannelPublicKeys orig_conv;
38338 orig_conv.inner = untag_ptr(orig);
38339 orig_conv.is_owned = ptr_is_owned(orig);
38340 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38341 orig_conv.is_owned = false;
38342 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
38343 uint64_t ret_ref = 0;
38344 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38345 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38349 jboolean __attribute__((export_name("TS_ChannelPublicKeys_eq"))) TS_ChannelPublicKeys_eq(uint64_t a, uint64_t b) {
38350 LDKChannelPublicKeys a_conv;
38351 a_conv.inner = untag_ptr(a);
38352 a_conv.is_owned = ptr_is_owned(a);
38353 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38354 a_conv.is_owned = false;
38355 LDKChannelPublicKeys b_conv;
38356 b_conv.inner = untag_ptr(b);
38357 b_conv.is_owned = ptr_is_owned(b);
38358 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38359 b_conv.is_owned = false;
38360 jboolean ret_conv = ChannelPublicKeys_eq(&a_conv, &b_conv);
38364 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_write"))) TS_ChannelPublicKeys_write(uint64_t obj) {
38365 LDKChannelPublicKeys obj_conv;
38366 obj_conv.inner = untag_ptr(obj);
38367 obj_conv.is_owned = ptr_is_owned(obj);
38368 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38369 obj_conv.is_owned = false;
38370 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
38371 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38372 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38373 CVec_u8Z_free(ret_var);
38377 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_read"))) TS_ChannelPublicKeys_read(int8_tArray ser) {
38378 LDKu8slice ser_ref;
38379 ser_ref.datalen = ser->arr_len;
38380 ser_ref.data = ser->elems;
38381 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
38382 *ret_conv = ChannelPublicKeys_read(ser_ref);
38384 return tag_ptr(ret_conv, true);
38387 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) {
38388 LDKPublicKey per_commitment_point_ref;
38389 CHECK(per_commitment_point->arr_len == 33);
38390 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
38391 LDKPublicKey broadcaster_delayed_payment_base_ref;
38392 CHECK(broadcaster_delayed_payment_base->arr_len == 33);
38393 memcpy(broadcaster_delayed_payment_base_ref.compressed_form, broadcaster_delayed_payment_base->elems, 33); FREE(broadcaster_delayed_payment_base);
38394 LDKPublicKey broadcaster_htlc_base_ref;
38395 CHECK(broadcaster_htlc_base->arr_len == 33);
38396 memcpy(broadcaster_htlc_base_ref.compressed_form, broadcaster_htlc_base->elems, 33); FREE(broadcaster_htlc_base);
38397 LDKPublicKey countersignatory_revocation_base_ref;
38398 CHECK(countersignatory_revocation_base->arr_len == 33);
38399 memcpy(countersignatory_revocation_base_ref.compressed_form, countersignatory_revocation_base->elems, 33); FREE(countersignatory_revocation_base);
38400 LDKPublicKey countersignatory_htlc_base_ref;
38401 CHECK(countersignatory_htlc_base->arr_len == 33);
38402 memcpy(countersignatory_htlc_base_ref.compressed_form, countersignatory_htlc_base->elems, 33); FREE(countersignatory_htlc_base);
38403 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);
38404 uint64_t ret_ref = 0;
38405 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38406 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38410 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) {
38411 LDKPublicKey per_commitment_point_ref;
38412 CHECK(per_commitment_point->arr_len == 33);
38413 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
38414 LDKChannelPublicKeys broadcaster_keys_conv;
38415 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
38416 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
38417 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
38418 broadcaster_keys_conv.is_owned = false;
38419 LDKChannelPublicKeys countersignatory_keys_conv;
38420 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
38421 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
38422 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
38423 countersignatory_keys_conv.is_owned = false;
38424 LDKTxCreationKeys ret_var = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
38425 uint64_t ret_ref = 0;
38426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38431 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) {
38432 LDKPublicKey revocation_key_ref;
38433 CHECK(revocation_key->arr_len == 33);
38434 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
38435 LDKPublicKey broadcaster_delayed_payment_key_ref;
38436 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
38437 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
38438 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
38439 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38440 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38441 CVec_u8Z_free(ret_var);
38445 void __attribute__((export_name("TS_HTLCOutputInCommitment_free"))) TS_HTLCOutputInCommitment_free(uint64_t this_obj) {
38446 LDKHTLCOutputInCommitment this_obj_conv;
38447 this_obj_conv.inner = untag_ptr(this_obj);
38448 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38450 HTLCOutputInCommitment_free(this_obj_conv);
38453 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_get_offered"))) TS_HTLCOutputInCommitment_get_offered(uint64_t this_ptr) {
38454 LDKHTLCOutputInCommitment this_ptr_conv;
38455 this_ptr_conv.inner = untag_ptr(this_ptr);
38456 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38458 this_ptr_conv.is_owned = false;
38459 jboolean ret_conv = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
38463 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_offered"))) TS_HTLCOutputInCommitment_set_offered(uint64_t this_ptr, jboolean val) {
38464 LDKHTLCOutputInCommitment this_ptr_conv;
38465 this_ptr_conv.inner = untag_ptr(this_ptr);
38466 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38468 this_ptr_conv.is_owned = false;
38469 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
38472 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_amount_msat"))) TS_HTLCOutputInCommitment_get_amount_msat(uint64_t this_ptr) {
38473 LDKHTLCOutputInCommitment this_ptr_conv;
38474 this_ptr_conv.inner = untag_ptr(this_ptr);
38475 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38477 this_ptr_conv.is_owned = false;
38478 int64_t ret_conv = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
38482 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_amount_msat"))) TS_HTLCOutputInCommitment_set_amount_msat(uint64_t this_ptr, int64_t val) {
38483 LDKHTLCOutputInCommitment this_ptr_conv;
38484 this_ptr_conv.inner = untag_ptr(this_ptr);
38485 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38487 this_ptr_conv.is_owned = false;
38488 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
38491 int32_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_cltv_expiry"))) TS_HTLCOutputInCommitment_get_cltv_expiry(uint64_t this_ptr) {
38492 LDKHTLCOutputInCommitment this_ptr_conv;
38493 this_ptr_conv.inner = untag_ptr(this_ptr);
38494 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38495 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38496 this_ptr_conv.is_owned = false;
38497 int32_t ret_conv = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
38501 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_cltv_expiry"))) TS_HTLCOutputInCommitment_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
38502 LDKHTLCOutputInCommitment this_ptr_conv;
38503 this_ptr_conv.inner = untag_ptr(this_ptr);
38504 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38506 this_ptr_conv.is_owned = false;
38507 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
38510 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_get_payment_hash"))) TS_HTLCOutputInCommitment_get_payment_hash(uint64_t this_ptr) {
38511 LDKHTLCOutputInCommitment this_ptr_conv;
38512 this_ptr_conv.inner = untag_ptr(this_ptr);
38513 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38515 this_ptr_conv.is_owned = false;
38516 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38517 memcpy(ret_arr->elems, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
38521 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_payment_hash"))) TS_HTLCOutputInCommitment_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
38522 LDKHTLCOutputInCommitment this_ptr_conv;
38523 this_ptr_conv.inner = untag_ptr(this_ptr);
38524 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38526 this_ptr_conv.is_owned = false;
38527 LDKThirtyTwoBytes val_ref;
38528 CHECK(val->arr_len == 32);
38529 memcpy(val_ref.data, val->elems, 32); FREE(val);
38530 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
38533 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_transaction_output_index"))) TS_HTLCOutputInCommitment_get_transaction_output_index(uint64_t this_ptr) {
38534 LDKHTLCOutputInCommitment this_ptr_conv;
38535 this_ptr_conv.inner = untag_ptr(this_ptr);
38536 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38537 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38538 this_ptr_conv.is_owned = false;
38539 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
38540 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
38541 uint64_t ret_ref = tag_ptr(ret_copy, true);
38545 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_transaction_output_index"))) TS_HTLCOutputInCommitment_set_transaction_output_index(uint64_t this_ptr, uint64_t val) {
38546 LDKHTLCOutputInCommitment this_ptr_conv;
38547 this_ptr_conv.inner = untag_ptr(this_ptr);
38548 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38550 this_ptr_conv.is_owned = false;
38551 void* val_ptr = untag_ptr(val);
38552 CHECK_ACCESS(val_ptr);
38553 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
38554 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
38555 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
38558 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) {
38559 LDKThirtyTwoBytes payment_hash_arg_ref;
38560 CHECK(payment_hash_arg->arr_len == 32);
38561 memcpy(payment_hash_arg_ref.data, payment_hash_arg->elems, 32); FREE(payment_hash_arg);
38562 void* transaction_output_index_arg_ptr = untag_ptr(transaction_output_index_arg);
38563 CHECK_ACCESS(transaction_output_index_arg_ptr);
38564 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(transaction_output_index_arg_ptr);
38565 transaction_output_index_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(transaction_output_index_arg));
38566 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
38567 uint64_t ret_ref = 0;
38568 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38569 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38573 static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
38574 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
38575 uint64_t ret_ref = 0;
38576 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38577 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38580 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone_ptr"))) TS_HTLCOutputInCommitment_clone_ptr(uint64_t arg) {
38581 LDKHTLCOutputInCommitment arg_conv;
38582 arg_conv.inner = untag_ptr(arg);
38583 arg_conv.is_owned = ptr_is_owned(arg);
38584 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38585 arg_conv.is_owned = false;
38586 int64_t ret_conv = HTLCOutputInCommitment_clone_ptr(&arg_conv);
38590 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone"))) TS_HTLCOutputInCommitment_clone(uint64_t orig) {
38591 LDKHTLCOutputInCommitment orig_conv;
38592 orig_conv.inner = untag_ptr(orig);
38593 orig_conv.is_owned = ptr_is_owned(orig);
38594 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38595 orig_conv.is_owned = false;
38596 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
38597 uint64_t ret_ref = 0;
38598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38599 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38603 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_eq"))) TS_HTLCOutputInCommitment_eq(uint64_t a, uint64_t b) {
38604 LDKHTLCOutputInCommitment a_conv;
38605 a_conv.inner = untag_ptr(a);
38606 a_conv.is_owned = ptr_is_owned(a);
38607 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38608 a_conv.is_owned = false;
38609 LDKHTLCOutputInCommitment b_conv;
38610 b_conv.inner = untag_ptr(b);
38611 b_conv.is_owned = ptr_is_owned(b);
38612 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38613 b_conv.is_owned = false;
38614 jboolean ret_conv = HTLCOutputInCommitment_eq(&a_conv, &b_conv);
38618 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_write"))) TS_HTLCOutputInCommitment_write(uint64_t obj) {
38619 LDKHTLCOutputInCommitment obj_conv;
38620 obj_conv.inner = untag_ptr(obj);
38621 obj_conv.is_owned = ptr_is_owned(obj);
38622 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38623 obj_conv.is_owned = false;
38624 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
38625 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38626 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38627 CVec_u8Z_free(ret_var);
38631 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_read"))) TS_HTLCOutputInCommitment_read(int8_tArray ser) {
38632 LDKu8slice ser_ref;
38633 ser_ref.datalen = ser->arr_len;
38634 ser_ref.data = ser->elems;
38635 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
38636 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
38638 return tag_ptr(ret_conv, true);
38641 int8_tArray __attribute__((export_name("TS_get_htlc_redeemscript"))) TS_get_htlc_redeemscript(uint64_t htlc, jboolean opt_anchors, uint64_t keys) {
38642 LDKHTLCOutputInCommitment htlc_conv;
38643 htlc_conv.inner = untag_ptr(htlc);
38644 htlc_conv.is_owned = ptr_is_owned(htlc);
38645 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
38646 htlc_conv.is_owned = false;
38647 LDKTxCreationKeys keys_conv;
38648 keys_conv.inner = untag_ptr(keys);
38649 keys_conv.is_owned = ptr_is_owned(keys);
38650 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
38651 keys_conv.is_owned = false;
38652 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, opt_anchors, &keys_conv);
38653 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38654 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38655 CVec_u8Z_free(ret_var);
38659 int8_tArray __attribute__((export_name("TS_make_funding_redeemscript"))) TS_make_funding_redeemscript(int8_tArray broadcaster, int8_tArray countersignatory) {
38660 LDKPublicKey broadcaster_ref;
38661 CHECK(broadcaster->arr_len == 33);
38662 memcpy(broadcaster_ref.compressed_form, broadcaster->elems, 33); FREE(broadcaster);
38663 LDKPublicKey countersignatory_ref;
38664 CHECK(countersignatory->arr_len == 33);
38665 memcpy(countersignatory_ref.compressed_form, countersignatory->elems, 33); FREE(countersignatory);
38666 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
38667 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38668 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38669 CVec_u8Z_free(ret_var);
38673 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) {
38674 uint8_t commitment_txid_arr[32];
38675 CHECK(commitment_txid->arr_len == 32);
38676 memcpy(commitment_txid_arr, commitment_txid->elems, 32); FREE(commitment_txid);
38677 uint8_t (*commitment_txid_ref)[32] = &commitment_txid_arr;
38678 LDKHTLCOutputInCommitment htlc_conv;
38679 htlc_conv.inner = untag_ptr(htlc);
38680 htlc_conv.is_owned = ptr_is_owned(htlc);
38681 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
38682 htlc_conv.is_owned = false;
38683 LDKPublicKey broadcaster_delayed_payment_key_ref;
38684 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
38685 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
38686 LDKPublicKey revocation_key_ref;
38687 CHECK(revocation_key->arr_len == 33);
38688 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
38689 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);
38690 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38691 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38692 Transaction_free(ret_var);
38696 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) {
38697 LDKSignature local_sig_ref;
38698 CHECK(local_sig->arr_len == 64);
38699 memcpy(local_sig_ref.compact_form, local_sig->elems, 64); FREE(local_sig);
38700 LDKSignature remote_sig_ref;
38701 CHECK(remote_sig->arr_len == 64);
38702 memcpy(remote_sig_ref.compact_form, remote_sig->elems, 64); FREE(remote_sig);
38703 LDKThirtyTwoBytes preimage_ref;
38704 CHECK(preimage->arr_len == 32);
38705 memcpy(preimage_ref.data, preimage->elems, 32); FREE(preimage);
38706 LDKu8slice redeem_script_ref;
38707 redeem_script_ref.datalen = redeem_script->arr_len;
38708 redeem_script_ref.data = redeem_script->elems;
38709 LDKWitness ret_var = build_htlc_input_witness(local_sig_ref, remote_sig_ref, preimage_ref, redeem_script_ref, opt_anchors);
38710 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38711 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38712 Witness_free(ret_var);
38713 FREE(redeem_script);
38717 int8_tArray __attribute__((export_name("TS_get_to_countersignatory_with_anchors_redeemscript"))) TS_get_to_countersignatory_with_anchors_redeemscript(int8_tArray payment_point) {
38718 LDKPublicKey payment_point_ref;
38719 CHECK(payment_point->arr_len == 33);
38720 memcpy(payment_point_ref.compressed_form, payment_point->elems, 33); FREE(payment_point);
38721 LDKCVec_u8Z ret_var = get_to_countersignatory_with_anchors_redeemscript(payment_point_ref);
38722 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38723 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38724 CVec_u8Z_free(ret_var);
38728 int8_tArray __attribute__((export_name("TS_get_anchor_redeemscript"))) TS_get_anchor_redeemscript(int8_tArray funding_pubkey) {
38729 LDKPublicKey funding_pubkey_ref;
38730 CHECK(funding_pubkey->arr_len == 33);
38731 memcpy(funding_pubkey_ref.compressed_form, funding_pubkey->elems, 33); FREE(funding_pubkey);
38732 LDKCVec_u8Z ret_var = get_anchor_redeemscript(funding_pubkey_ref);
38733 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38734 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38735 CVec_u8Z_free(ret_var);
38739 int8_tArray __attribute__((export_name("TS_build_anchor_input_witness"))) TS_build_anchor_input_witness(int8_tArray funding_key, int8_tArray funding_sig) {
38740 LDKPublicKey funding_key_ref;
38741 CHECK(funding_key->arr_len == 33);
38742 memcpy(funding_key_ref.compressed_form, funding_key->elems, 33); FREE(funding_key);
38743 LDKSignature funding_sig_ref;
38744 CHECK(funding_sig->arr_len == 64);
38745 memcpy(funding_sig_ref.compact_form, funding_sig->elems, 64); FREE(funding_sig);
38746 LDKWitness ret_var = build_anchor_input_witness(funding_key_ref, funding_sig_ref);
38747 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38748 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38749 Witness_free(ret_var);
38753 void __attribute__((export_name("TS_ChannelTransactionParameters_free"))) TS_ChannelTransactionParameters_free(uint64_t this_obj) {
38754 LDKChannelTransactionParameters this_obj_conv;
38755 this_obj_conv.inner = untag_ptr(this_obj);
38756 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38757 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38758 ChannelTransactionParameters_free(this_obj_conv);
38761 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_pubkeys"))) TS_ChannelTransactionParameters_get_holder_pubkeys(uint64_t this_ptr) {
38762 LDKChannelTransactionParameters this_ptr_conv;
38763 this_ptr_conv.inner = untag_ptr(this_ptr);
38764 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38766 this_ptr_conv.is_owned = false;
38767 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
38768 uint64_t ret_ref = 0;
38769 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38770 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38774 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_pubkeys"))) TS_ChannelTransactionParameters_set_holder_pubkeys(uint64_t this_ptr, uint64_t val) {
38775 LDKChannelTransactionParameters this_ptr_conv;
38776 this_ptr_conv.inner = untag_ptr(this_ptr);
38777 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38779 this_ptr_conv.is_owned = false;
38780 LDKChannelPublicKeys val_conv;
38781 val_conv.inner = untag_ptr(val);
38782 val_conv.is_owned = ptr_is_owned(val);
38783 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38784 val_conv = ChannelPublicKeys_clone(&val_conv);
38785 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
38788 int16_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_get_holder_selected_contest_delay(uint64_t this_ptr) {
38789 LDKChannelTransactionParameters this_ptr_conv;
38790 this_ptr_conv.inner = untag_ptr(this_ptr);
38791 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38792 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38793 this_ptr_conv.is_owned = false;
38794 int16_t ret_conv = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
38798 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) {
38799 LDKChannelTransactionParameters this_ptr_conv;
38800 this_ptr_conv.inner = untag_ptr(this_ptr);
38801 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38802 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38803 this_ptr_conv.is_owned = false;
38804 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
38807 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_get_is_outbound_from_holder"))) TS_ChannelTransactionParameters_get_is_outbound_from_holder(uint64_t this_ptr) {
38808 LDKChannelTransactionParameters this_ptr_conv;
38809 this_ptr_conv.inner = untag_ptr(this_ptr);
38810 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38812 this_ptr_conv.is_owned = false;
38813 jboolean ret_conv = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
38817 void __attribute__((export_name("TS_ChannelTransactionParameters_set_is_outbound_from_holder"))) TS_ChannelTransactionParameters_set_is_outbound_from_holder(uint64_t this_ptr, jboolean val) {
38818 LDKChannelTransactionParameters this_ptr_conv;
38819 this_ptr_conv.inner = untag_ptr(this_ptr);
38820 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38822 this_ptr_conv.is_owned = false;
38823 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
38826 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_counterparty_parameters"))) TS_ChannelTransactionParameters_get_counterparty_parameters(uint64_t this_ptr) {
38827 LDKChannelTransactionParameters this_ptr_conv;
38828 this_ptr_conv.inner = untag_ptr(this_ptr);
38829 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38831 this_ptr_conv.is_owned = false;
38832 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
38833 uint64_t ret_ref = 0;
38834 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38835 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38839 void __attribute__((export_name("TS_ChannelTransactionParameters_set_counterparty_parameters"))) TS_ChannelTransactionParameters_set_counterparty_parameters(uint64_t this_ptr, uint64_t val) {
38840 LDKChannelTransactionParameters this_ptr_conv;
38841 this_ptr_conv.inner = untag_ptr(this_ptr);
38842 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38844 this_ptr_conv.is_owned = false;
38845 LDKCounterpartyChannelTransactionParameters val_conv;
38846 val_conv.inner = untag_ptr(val);
38847 val_conv.is_owned = ptr_is_owned(val);
38848 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38849 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
38850 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
38853 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_funding_outpoint"))) TS_ChannelTransactionParameters_get_funding_outpoint(uint64_t this_ptr) {
38854 LDKChannelTransactionParameters this_ptr_conv;
38855 this_ptr_conv.inner = untag_ptr(this_ptr);
38856 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38858 this_ptr_conv.is_owned = false;
38859 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
38860 uint64_t ret_ref = 0;
38861 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38862 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38866 void __attribute__((export_name("TS_ChannelTransactionParameters_set_funding_outpoint"))) TS_ChannelTransactionParameters_set_funding_outpoint(uint64_t this_ptr, uint64_t val) {
38867 LDKChannelTransactionParameters this_ptr_conv;
38868 this_ptr_conv.inner = untag_ptr(this_ptr);
38869 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38871 this_ptr_conv.is_owned = false;
38872 LDKOutPoint val_conv;
38873 val_conv.inner = untag_ptr(val);
38874 val_conv.is_owned = ptr_is_owned(val);
38875 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38876 val_conv = OutPoint_clone(&val_conv);
38877 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
38880 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_opt_anchors"))) TS_ChannelTransactionParameters_get_opt_anchors(uint64_t this_ptr) {
38881 LDKChannelTransactionParameters this_ptr_conv;
38882 this_ptr_conv.inner = untag_ptr(this_ptr);
38883 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38885 this_ptr_conv.is_owned = false;
38886 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_anchors(&this_ptr_conv));
38890 void __attribute__((export_name("TS_ChannelTransactionParameters_set_opt_anchors"))) TS_ChannelTransactionParameters_set_opt_anchors(uint64_t this_ptr, uint32_t val) {
38891 LDKChannelTransactionParameters this_ptr_conv;
38892 this_ptr_conv.inner = untag_ptr(this_ptr);
38893 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38895 this_ptr_conv.is_owned = false;
38896 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38897 ChannelTransactionParameters_set_opt_anchors(&this_ptr_conv, val_conv);
38900 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) {
38901 LDKChannelTransactionParameters this_ptr_conv;
38902 this_ptr_conv.inner = untag_ptr(this_ptr);
38903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38905 this_ptr_conv.is_owned = false;
38906 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_non_zero_fee_anchors(&this_ptr_conv));
38910 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) {
38911 LDKChannelTransactionParameters this_ptr_conv;
38912 this_ptr_conv.inner = untag_ptr(this_ptr);
38913 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38914 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38915 this_ptr_conv.is_owned = false;
38916 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38917 ChannelTransactionParameters_set_opt_non_zero_fee_anchors(&this_ptr_conv, val_conv);
38920 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) {
38921 LDKChannelPublicKeys holder_pubkeys_arg_conv;
38922 holder_pubkeys_arg_conv.inner = untag_ptr(holder_pubkeys_arg);
38923 holder_pubkeys_arg_conv.is_owned = ptr_is_owned(holder_pubkeys_arg);
38924 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
38925 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
38926 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
38927 counterparty_parameters_arg_conv.inner = untag_ptr(counterparty_parameters_arg);
38928 counterparty_parameters_arg_conv.is_owned = ptr_is_owned(counterparty_parameters_arg);
38929 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
38930 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
38931 LDKOutPoint funding_outpoint_arg_conv;
38932 funding_outpoint_arg_conv.inner = untag_ptr(funding_outpoint_arg);
38933 funding_outpoint_arg_conv.is_owned = ptr_is_owned(funding_outpoint_arg);
38934 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
38935 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
38936 LDKCOption_NoneZ opt_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_anchors_arg);
38937 LDKCOption_NoneZ opt_non_zero_fee_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_non_zero_fee_anchors_arg);
38938 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);
38939 uint64_t ret_ref = 0;
38940 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38941 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38945 static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
38946 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
38947 uint64_t ret_ref = 0;
38948 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38949 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38952 int64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone_ptr"))) TS_ChannelTransactionParameters_clone_ptr(uint64_t arg) {
38953 LDKChannelTransactionParameters arg_conv;
38954 arg_conv.inner = untag_ptr(arg);
38955 arg_conv.is_owned = ptr_is_owned(arg);
38956 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38957 arg_conv.is_owned = false;
38958 int64_t ret_conv = ChannelTransactionParameters_clone_ptr(&arg_conv);
38962 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone"))) TS_ChannelTransactionParameters_clone(uint64_t orig) {
38963 LDKChannelTransactionParameters orig_conv;
38964 orig_conv.inner = untag_ptr(orig);
38965 orig_conv.is_owned = ptr_is_owned(orig);
38966 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38967 orig_conv.is_owned = false;
38968 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
38969 uint64_t ret_ref = 0;
38970 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38971 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38975 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_eq"))) TS_ChannelTransactionParameters_eq(uint64_t a, uint64_t b) {
38976 LDKChannelTransactionParameters a_conv;
38977 a_conv.inner = untag_ptr(a);
38978 a_conv.is_owned = ptr_is_owned(a);
38979 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38980 a_conv.is_owned = false;
38981 LDKChannelTransactionParameters b_conv;
38982 b_conv.inner = untag_ptr(b);
38983 b_conv.is_owned = ptr_is_owned(b);
38984 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38985 b_conv.is_owned = false;
38986 jboolean ret_conv = ChannelTransactionParameters_eq(&a_conv, &b_conv);
38990 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_free"))) TS_CounterpartyChannelTransactionParameters_free(uint64_t this_obj) {
38991 LDKCounterpartyChannelTransactionParameters this_obj_conv;
38992 this_obj_conv.inner = untag_ptr(this_obj);
38993 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38995 CounterpartyChannelTransactionParameters_free(this_obj_conv);
38998 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_pubkeys"))) TS_CounterpartyChannelTransactionParameters_get_pubkeys(uint64_t this_ptr) {
38999 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39000 this_ptr_conv.inner = untag_ptr(this_ptr);
39001 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39003 this_ptr_conv.is_owned = false;
39004 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
39005 uint64_t ret_ref = 0;
39006 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39007 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39011 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_pubkeys"))) TS_CounterpartyChannelTransactionParameters_set_pubkeys(uint64_t this_ptr, uint64_t val) {
39012 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39013 this_ptr_conv.inner = untag_ptr(this_ptr);
39014 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39016 this_ptr_conv.is_owned = false;
39017 LDKChannelPublicKeys val_conv;
39018 val_conv.inner = untag_ptr(val);
39019 val_conv.is_owned = ptr_is_owned(val);
39020 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39021 val_conv = ChannelPublicKeys_clone(&val_conv);
39022 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
39025 int16_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(uint64_t this_ptr) {
39026 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39027 this_ptr_conv.inner = untag_ptr(this_ptr);
39028 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39030 this_ptr_conv.is_owned = false;
39031 int16_t ret_conv = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
39035 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(uint64_t this_ptr, int16_t val) {
39036 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39037 this_ptr_conv.inner = untag_ptr(this_ptr);
39038 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39040 this_ptr_conv.is_owned = false;
39041 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
39044 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_new"))) TS_CounterpartyChannelTransactionParameters_new(uint64_t pubkeys_arg, int16_t selected_contest_delay_arg) {
39045 LDKChannelPublicKeys pubkeys_arg_conv;
39046 pubkeys_arg_conv.inner = untag_ptr(pubkeys_arg);
39047 pubkeys_arg_conv.is_owned = ptr_is_owned(pubkeys_arg);
39048 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
39049 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
39050 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
39051 uint64_t ret_ref = 0;
39052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39053 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39057 static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
39058 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
39059 uint64_t ret_ref = 0;
39060 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39061 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39064 int64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone_ptr"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint64_t arg) {
39065 LDKCounterpartyChannelTransactionParameters arg_conv;
39066 arg_conv.inner = untag_ptr(arg);
39067 arg_conv.is_owned = ptr_is_owned(arg);
39068 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39069 arg_conv.is_owned = false;
39070 int64_t ret_conv = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
39074 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone"))) TS_CounterpartyChannelTransactionParameters_clone(uint64_t orig) {
39075 LDKCounterpartyChannelTransactionParameters orig_conv;
39076 orig_conv.inner = untag_ptr(orig);
39077 orig_conv.is_owned = ptr_is_owned(orig);
39078 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39079 orig_conv.is_owned = false;
39080 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
39081 uint64_t ret_ref = 0;
39082 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39083 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39087 jboolean __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_eq"))) TS_CounterpartyChannelTransactionParameters_eq(uint64_t a, uint64_t b) {
39088 LDKCounterpartyChannelTransactionParameters a_conv;
39089 a_conv.inner = untag_ptr(a);
39090 a_conv.is_owned = ptr_is_owned(a);
39091 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39092 a_conv.is_owned = false;
39093 LDKCounterpartyChannelTransactionParameters b_conv;
39094 b_conv.inner = untag_ptr(b);
39095 b_conv.is_owned = ptr_is_owned(b);
39096 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39097 b_conv.is_owned = false;
39098 jboolean ret_conv = CounterpartyChannelTransactionParameters_eq(&a_conv, &b_conv);
39102 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_is_populated"))) TS_ChannelTransactionParameters_is_populated(uint64_t this_arg) {
39103 LDKChannelTransactionParameters this_arg_conv;
39104 this_arg_conv.inner = untag_ptr(this_arg);
39105 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39106 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39107 this_arg_conv.is_owned = false;
39108 jboolean ret_conv = ChannelTransactionParameters_is_populated(&this_arg_conv);
39112 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_holder_broadcastable"))) TS_ChannelTransactionParameters_as_holder_broadcastable(uint64_t this_arg) {
39113 LDKChannelTransactionParameters this_arg_conv;
39114 this_arg_conv.inner = untag_ptr(this_arg);
39115 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39117 this_arg_conv.is_owned = false;
39118 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
39119 uint64_t ret_ref = 0;
39120 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39121 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39125 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_counterparty_broadcastable"))) TS_ChannelTransactionParameters_as_counterparty_broadcastable(uint64_t this_arg) {
39126 LDKChannelTransactionParameters this_arg_conv;
39127 this_arg_conv.inner = untag_ptr(this_arg);
39128 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39130 this_arg_conv.is_owned = false;
39131 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
39132 uint64_t ret_ref = 0;
39133 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39134 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39138 int8_tArray __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_write"))) TS_CounterpartyChannelTransactionParameters_write(uint64_t obj) {
39139 LDKCounterpartyChannelTransactionParameters obj_conv;
39140 obj_conv.inner = untag_ptr(obj);
39141 obj_conv.is_owned = ptr_is_owned(obj);
39142 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39143 obj_conv.is_owned = false;
39144 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
39145 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39146 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39147 CVec_u8Z_free(ret_var);
39151 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_read"))) TS_CounterpartyChannelTransactionParameters_read(int8_tArray ser) {
39152 LDKu8slice ser_ref;
39153 ser_ref.datalen = ser->arr_len;
39154 ser_ref.data = ser->elems;
39155 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
39156 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
39158 return tag_ptr(ret_conv, true);
39161 int8_tArray __attribute__((export_name("TS_ChannelTransactionParameters_write"))) TS_ChannelTransactionParameters_write(uint64_t obj) {
39162 LDKChannelTransactionParameters obj_conv;
39163 obj_conv.inner = untag_ptr(obj);
39164 obj_conv.is_owned = ptr_is_owned(obj);
39165 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39166 obj_conv.is_owned = false;
39167 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
39168 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39169 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39170 CVec_u8Z_free(ret_var);
39174 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_read"))) TS_ChannelTransactionParameters_read(int8_tArray ser) {
39175 LDKu8slice ser_ref;
39176 ser_ref.datalen = ser->arr_len;
39177 ser_ref.data = ser->elems;
39178 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
39179 *ret_conv = ChannelTransactionParameters_read(ser_ref);
39181 return tag_ptr(ret_conv, true);
39184 void __attribute__((export_name("TS_DirectedChannelTransactionParameters_free"))) TS_DirectedChannelTransactionParameters_free(uint64_t this_obj) {
39185 LDKDirectedChannelTransactionParameters this_obj_conv;
39186 this_obj_conv.inner = untag_ptr(this_obj);
39187 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39189 DirectedChannelTransactionParameters_free(this_obj_conv);
39192 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_broadcaster_pubkeys"))) TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(uint64_t this_arg) {
39193 LDKDirectedChannelTransactionParameters this_arg_conv;
39194 this_arg_conv.inner = untag_ptr(this_arg);
39195 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39197 this_arg_conv.is_owned = false;
39198 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
39199 uint64_t ret_ref = 0;
39200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39201 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39205 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_countersignatory_pubkeys"))) TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(uint64_t this_arg) {
39206 LDKDirectedChannelTransactionParameters this_arg_conv;
39207 this_arg_conv.inner = untag_ptr(this_arg);
39208 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39210 this_arg_conv.is_owned = false;
39211 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
39212 uint64_t ret_ref = 0;
39213 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39214 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39218 int16_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_contest_delay"))) TS_DirectedChannelTransactionParameters_contest_delay(uint64_t this_arg) {
39219 LDKDirectedChannelTransactionParameters this_arg_conv;
39220 this_arg_conv.inner = untag_ptr(this_arg);
39221 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39222 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39223 this_arg_conv.is_owned = false;
39224 int16_t ret_conv = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
39228 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_is_outbound"))) TS_DirectedChannelTransactionParameters_is_outbound(uint64_t this_arg) {
39229 LDKDirectedChannelTransactionParameters this_arg_conv;
39230 this_arg_conv.inner = untag_ptr(this_arg);
39231 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39233 this_arg_conv.is_owned = false;
39234 jboolean ret_conv = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
39238 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_funding_outpoint"))) TS_DirectedChannelTransactionParameters_funding_outpoint(uint64_t this_arg) {
39239 LDKDirectedChannelTransactionParameters 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 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
39245 uint64_t ret_ref = 0;
39246 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39247 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39251 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_opt_anchors"))) TS_DirectedChannelTransactionParameters_opt_anchors(uint64_t this_arg) {
39252 LDKDirectedChannelTransactionParameters this_arg_conv;
39253 this_arg_conv.inner = untag_ptr(this_arg);
39254 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39256 this_arg_conv.is_owned = false;
39257 jboolean ret_conv = DirectedChannelTransactionParameters_opt_anchors(&this_arg_conv);
39261 void __attribute__((export_name("TS_HolderCommitmentTransaction_free"))) TS_HolderCommitmentTransaction_free(uint64_t this_obj) {
39262 LDKHolderCommitmentTransaction this_obj_conv;
39263 this_obj_conv.inner = untag_ptr(this_obj);
39264 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39266 HolderCommitmentTransaction_free(this_obj_conv);
39269 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_sig"))) TS_HolderCommitmentTransaction_get_counterparty_sig(uint64_t this_ptr) {
39270 LDKHolderCommitmentTransaction this_ptr_conv;
39271 this_ptr_conv.inner = untag_ptr(this_ptr);
39272 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39274 this_ptr_conv.is_owned = false;
39275 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39276 memcpy(ret_arr->elems, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
39280 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_sig"))) TS_HolderCommitmentTransaction_set_counterparty_sig(uint64_t this_ptr, int8_tArray val) {
39281 LDKHolderCommitmentTransaction this_ptr_conv;
39282 this_ptr_conv.inner = untag_ptr(this_ptr);
39283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39285 this_ptr_conv.is_owned = false;
39286 LDKSignature val_ref;
39287 CHECK(val->arr_len == 64);
39288 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
39289 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
39292 ptrArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(uint64_t this_ptr) {
39293 LDKHolderCommitmentTransaction this_ptr_conv;
39294 this_ptr_conv.inner = untag_ptr(this_ptr);
39295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39297 this_ptr_conv.is_owned = false;
39298 LDKCVec_SignatureZ ret_var = HolderCommitmentTransaction_get_counterparty_htlc_sigs(&this_ptr_conv);
39299 ptrArray ret_arr = NULL;
39300 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
39301 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
39302 for (size_t m = 0; m < ret_var.datalen; m++) {
39303 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
39304 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
39305 ret_arr_ptr[m] = ret_conv_12_arr;
39308 FREE(ret_var.data);
39312 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(uint64_t this_ptr, ptrArray val) {
39313 LDKHolderCommitmentTransaction this_ptr_conv;
39314 this_ptr_conv.inner = untag_ptr(this_ptr);
39315 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39317 this_ptr_conv.is_owned = false;
39318 LDKCVec_SignatureZ val_constr;
39319 val_constr.datalen = val->arr_len;
39320 if (val_constr.datalen > 0)
39321 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
39323 val_constr.data = NULL;
39324 int8_tArray* val_vals = (void*) val->elems;
39325 for (size_t m = 0; m < val_constr.datalen; m++) {
39326 int8_tArray val_conv_12 = val_vals[m];
39327 LDKSignature val_conv_12_ref;
39328 CHECK(val_conv_12->arr_len == 64);
39329 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
39330 val_constr.data[m] = val_conv_12_ref;
39333 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
39336 static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
39337 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
39338 uint64_t ret_ref = 0;
39339 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39340 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39343 int64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone_ptr"))) TS_HolderCommitmentTransaction_clone_ptr(uint64_t arg) {
39344 LDKHolderCommitmentTransaction arg_conv;
39345 arg_conv.inner = untag_ptr(arg);
39346 arg_conv.is_owned = ptr_is_owned(arg);
39347 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39348 arg_conv.is_owned = false;
39349 int64_t ret_conv = HolderCommitmentTransaction_clone_ptr(&arg_conv);
39353 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone"))) TS_HolderCommitmentTransaction_clone(uint64_t orig) {
39354 LDKHolderCommitmentTransaction orig_conv;
39355 orig_conv.inner = untag_ptr(orig);
39356 orig_conv.is_owned = ptr_is_owned(orig);
39357 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39358 orig_conv.is_owned = false;
39359 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
39360 uint64_t ret_ref = 0;
39361 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39362 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39366 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_write"))) TS_HolderCommitmentTransaction_write(uint64_t obj) {
39367 LDKHolderCommitmentTransaction obj_conv;
39368 obj_conv.inner = untag_ptr(obj);
39369 obj_conv.is_owned = ptr_is_owned(obj);
39370 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39371 obj_conv.is_owned = false;
39372 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
39373 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39374 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39375 CVec_u8Z_free(ret_var);
39379 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_read"))) TS_HolderCommitmentTransaction_read(int8_tArray ser) {
39380 LDKu8slice ser_ref;
39381 ser_ref.datalen = ser->arr_len;
39382 ser_ref.data = ser->elems;
39383 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
39384 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
39386 return tag_ptr(ret_conv, true);
39389 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) {
39390 LDKCommitmentTransaction commitment_tx_conv;
39391 commitment_tx_conv.inner = untag_ptr(commitment_tx);
39392 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
39393 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
39394 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
39395 LDKSignature counterparty_sig_ref;
39396 CHECK(counterparty_sig->arr_len == 64);
39397 memcpy(counterparty_sig_ref.compact_form, counterparty_sig->elems, 64); FREE(counterparty_sig);
39398 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
39399 counterparty_htlc_sigs_constr.datalen = counterparty_htlc_sigs->arr_len;
39400 if (counterparty_htlc_sigs_constr.datalen > 0)
39401 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
39403 counterparty_htlc_sigs_constr.data = NULL;
39404 int8_tArray* counterparty_htlc_sigs_vals = (void*) counterparty_htlc_sigs->elems;
39405 for (size_t m = 0; m < counterparty_htlc_sigs_constr.datalen; m++) {
39406 int8_tArray counterparty_htlc_sigs_conv_12 = counterparty_htlc_sigs_vals[m];
39407 LDKSignature counterparty_htlc_sigs_conv_12_ref;
39408 CHECK(counterparty_htlc_sigs_conv_12->arr_len == 64);
39409 memcpy(counterparty_htlc_sigs_conv_12_ref.compact_form, counterparty_htlc_sigs_conv_12->elems, 64); FREE(counterparty_htlc_sigs_conv_12);
39410 counterparty_htlc_sigs_constr.data[m] = counterparty_htlc_sigs_conv_12_ref;
39412 FREE(counterparty_htlc_sigs);
39413 LDKPublicKey holder_funding_key_ref;
39414 CHECK(holder_funding_key->arr_len == 33);
39415 memcpy(holder_funding_key_ref.compressed_form, holder_funding_key->elems, 33); FREE(holder_funding_key);
39416 LDKPublicKey counterparty_funding_key_ref;
39417 CHECK(counterparty_funding_key->arr_len == 33);
39418 memcpy(counterparty_funding_key_ref.compressed_form, counterparty_funding_key->elems, 33); FREE(counterparty_funding_key);
39419 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
39420 uint64_t ret_ref = 0;
39421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39426 void __attribute__((export_name("TS_BuiltCommitmentTransaction_free"))) TS_BuiltCommitmentTransaction_free(uint64_t this_obj) {
39427 LDKBuiltCommitmentTransaction this_obj_conv;
39428 this_obj_conv.inner = untag_ptr(this_obj);
39429 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39430 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39431 BuiltCommitmentTransaction_free(this_obj_conv);
39434 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_transaction"))) TS_BuiltCommitmentTransaction_get_transaction(uint64_t this_ptr) {
39435 LDKBuiltCommitmentTransaction this_ptr_conv;
39436 this_ptr_conv.inner = untag_ptr(this_ptr);
39437 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39439 this_ptr_conv.is_owned = false;
39440 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
39441 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39442 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39443 Transaction_free(ret_var);
39447 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_transaction"))) TS_BuiltCommitmentTransaction_set_transaction(uint64_t this_ptr, int8_tArray val) {
39448 LDKBuiltCommitmentTransaction this_ptr_conv;
39449 this_ptr_conv.inner = untag_ptr(this_ptr);
39450 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39452 this_ptr_conv.is_owned = false;
39453 LDKTransaction val_ref;
39454 val_ref.datalen = val->arr_len;
39455 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
39456 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
39457 val_ref.data_is_owned = true;
39458 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
39461 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_txid"))) TS_BuiltCommitmentTransaction_get_txid(uint64_t this_ptr) {
39462 LDKBuiltCommitmentTransaction this_ptr_conv;
39463 this_ptr_conv.inner = untag_ptr(this_ptr);
39464 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39466 this_ptr_conv.is_owned = false;
39467 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39468 memcpy(ret_arr->elems, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
39472 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_txid"))) TS_BuiltCommitmentTransaction_set_txid(uint64_t this_ptr, int8_tArray val) {
39473 LDKBuiltCommitmentTransaction this_ptr_conv;
39474 this_ptr_conv.inner = untag_ptr(this_ptr);
39475 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39477 this_ptr_conv.is_owned = false;
39478 LDKThirtyTwoBytes val_ref;
39479 CHECK(val->arr_len == 32);
39480 memcpy(val_ref.data, val->elems, 32); FREE(val);
39481 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
39484 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_new"))) TS_BuiltCommitmentTransaction_new(int8_tArray transaction_arg, int8_tArray txid_arg) {
39485 LDKTransaction transaction_arg_ref;
39486 transaction_arg_ref.datalen = transaction_arg->arr_len;
39487 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
39488 memcpy(transaction_arg_ref.data, transaction_arg->elems, transaction_arg_ref.datalen); FREE(transaction_arg);
39489 transaction_arg_ref.data_is_owned = true;
39490 LDKThirtyTwoBytes txid_arg_ref;
39491 CHECK(txid_arg->arr_len == 32);
39492 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
39493 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
39494 uint64_t ret_ref = 0;
39495 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39496 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39500 static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
39501 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
39502 uint64_t ret_ref = 0;
39503 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39504 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39507 int64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone_ptr"))) TS_BuiltCommitmentTransaction_clone_ptr(uint64_t arg) {
39508 LDKBuiltCommitmentTransaction arg_conv;
39509 arg_conv.inner = untag_ptr(arg);
39510 arg_conv.is_owned = ptr_is_owned(arg);
39511 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39512 arg_conv.is_owned = false;
39513 int64_t ret_conv = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
39517 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone"))) TS_BuiltCommitmentTransaction_clone(uint64_t orig) {
39518 LDKBuiltCommitmentTransaction orig_conv;
39519 orig_conv.inner = untag_ptr(orig);
39520 orig_conv.is_owned = ptr_is_owned(orig);
39521 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39522 orig_conv.is_owned = false;
39523 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
39524 uint64_t ret_ref = 0;
39525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39526 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39530 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_write"))) TS_BuiltCommitmentTransaction_write(uint64_t obj) {
39531 LDKBuiltCommitmentTransaction obj_conv;
39532 obj_conv.inner = untag_ptr(obj);
39533 obj_conv.is_owned = ptr_is_owned(obj);
39534 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39535 obj_conv.is_owned = false;
39536 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
39537 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39538 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39539 CVec_u8Z_free(ret_var);
39543 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_read"))) TS_BuiltCommitmentTransaction_read(int8_tArray ser) {
39544 LDKu8slice ser_ref;
39545 ser_ref.datalen = ser->arr_len;
39546 ser_ref.data = ser->elems;
39547 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
39548 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
39550 return tag_ptr(ret_conv, true);
39553 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) {
39554 LDKBuiltCommitmentTransaction this_arg_conv;
39555 this_arg_conv.inner = untag_ptr(this_arg);
39556 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39557 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39558 this_arg_conv.is_owned = false;
39559 LDKu8slice funding_redeemscript_ref;
39560 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39561 funding_redeemscript_ref.data = funding_redeemscript->elems;
39562 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39563 memcpy(ret_arr->elems, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
39564 FREE(funding_redeemscript);
39568 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_sign_counterparty_commitment"))) TS_BuiltCommitmentTransaction_sign_counterparty_commitment(uint64_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
39569 LDKBuiltCommitmentTransaction this_arg_conv;
39570 this_arg_conv.inner = untag_ptr(this_arg);
39571 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39573 this_arg_conv.is_owned = false;
39574 uint8_t funding_key_arr[32];
39575 CHECK(funding_key->arr_len == 32);
39576 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39577 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
39578 LDKu8slice funding_redeemscript_ref;
39579 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39580 funding_redeemscript_ref.data = funding_redeemscript->elems;
39581 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39582 memcpy(ret_arr->elems, BuiltCommitmentTransaction_sign_counterparty_commitment(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
39583 FREE(funding_redeemscript);
39587 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_sign_holder_commitment"))) TS_BuiltCommitmentTransaction_sign_holder_commitment(uint64_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis, uint64_t entropy_source) {
39588 LDKBuiltCommitmentTransaction this_arg_conv;
39589 this_arg_conv.inner = untag_ptr(this_arg);
39590 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39592 this_arg_conv.is_owned = false;
39593 uint8_t funding_key_arr[32];
39594 CHECK(funding_key->arr_len == 32);
39595 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39596 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
39597 LDKu8slice funding_redeemscript_ref;
39598 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39599 funding_redeemscript_ref.data = funding_redeemscript->elems;
39600 void* entropy_source_ptr = untag_ptr(entropy_source);
39601 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
39602 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
39603 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39604 memcpy(ret_arr->elems, BuiltCommitmentTransaction_sign_holder_commitment(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis, entropy_source_conv).compact_form, 64);
39605 FREE(funding_redeemscript);
39609 void __attribute__((export_name("TS_ClosingTransaction_free"))) TS_ClosingTransaction_free(uint64_t this_obj) {
39610 LDKClosingTransaction this_obj_conv;
39611 this_obj_conv.inner = untag_ptr(this_obj);
39612 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39614 ClosingTransaction_free(this_obj_conv);
39617 static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
39618 LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
39619 uint64_t ret_ref = 0;
39620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39624 int64_t __attribute__((export_name("TS_ClosingTransaction_clone_ptr"))) TS_ClosingTransaction_clone_ptr(uint64_t arg) {
39625 LDKClosingTransaction arg_conv;
39626 arg_conv.inner = untag_ptr(arg);
39627 arg_conv.is_owned = ptr_is_owned(arg);
39628 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39629 arg_conv.is_owned = false;
39630 int64_t ret_conv = ClosingTransaction_clone_ptr(&arg_conv);
39634 uint64_t __attribute__((export_name("TS_ClosingTransaction_clone"))) TS_ClosingTransaction_clone(uint64_t orig) {
39635 LDKClosingTransaction orig_conv;
39636 orig_conv.inner = untag_ptr(orig);
39637 orig_conv.is_owned = ptr_is_owned(orig);
39638 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39639 orig_conv.is_owned = false;
39640 LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
39641 uint64_t ret_ref = 0;
39642 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39643 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39647 int64_t __attribute__((export_name("TS_ClosingTransaction_hash"))) TS_ClosingTransaction_hash(uint64_t o) {
39648 LDKClosingTransaction o_conv;
39649 o_conv.inner = untag_ptr(o);
39650 o_conv.is_owned = ptr_is_owned(o);
39651 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
39652 o_conv.is_owned = false;
39653 int64_t ret_conv = ClosingTransaction_hash(&o_conv);
39657 jboolean __attribute__((export_name("TS_ClosingTransaction_eq"))) TS_ClosingTransaction_eq(uint64_t a, uint64_t b) {
39658 LDKClosingTransaction a_conv;
39659 a_conv.inner = untag_ptr(a);
39660 a_conv.is_owned = ptr_is_owned(a);
39661 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39662 a_conv.is_owned = false;
39663 LDKClosingTransaction b_conv;
39664 b_conv.inner = untag_ptr(b);
39665 b_conv.is_owned = ptr_is_owned(b);
39666 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39667 b_conv.is_owned = false;
39668 jboolean ret_conv = ClosingTransaction_eq(&a_conv, &b_conv);
39672 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) {
39673 LDKCVec_u8Z to_holder_script_ref;
39674 to_holder_script_ref.datalen = to_holder_script->arr_len;
39675 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
39676 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
39677 LDKCVec_u8Z to_counterparty_script_ref;
39678 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
39679 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
39680 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
39681 LDKOutPoint funding_outpoint_conv;
39682 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
39683 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
39684 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
39685 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
39686 LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
39687 uint64_t ret_ref = 0;
39688 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39689 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39693 uint64_t __attribute__((export_name("TS_ClosingTransaction_trust"))) TS_ClosingTransaction_trust(uint64_t this_arg) {
39694 LDKClosingTransaction this_arg_conv;
39695 this_arg_conv.inner = untag_ptr(this_arg);
39696 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39698 this_arg_conv.is_owned = false;
39699 LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
39700 uint64_t ret_ref = 0;
39701 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39702 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39706 uint64_t __attribute__((export_name("TS_ClosingTransaction_verify"))) TS_ClosingTransaction_verify(uint64_t this_arg, uint64_t funding_outpoint) {
39707 LDKClosingTransaction this_arg_conv;
39708 this_arg_conv.inner = untag_ptr(this_arg);
39709 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39711 this_arg_conv.is_owned = false;
39712 LDKOutPoint funding_outpoint_conv;
39713 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
39714 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
39715 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
39716 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
39717 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
39718 *ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
39719 return tag_ptr(ret_conv, true);
39722 int64_t __attribute__((export_name("TS_ClosingTransaction_to_holder_value_sat"))) TS_ClosingTransaction_to_holder_value_sat(uint64_t this_arg) {
39723 LDKClosingTransaction this_arg_conv;
39724 this_arg_conv.inner = untag_ptr(this_arg);
39725 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39726 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39727 this_arg_conv.is_owned = false;
39728 int64_t ret_conv = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
39732 int64_t __attribute__((export_name("TS_ClosingTransaction_to_counterparty_value_sat"))) TS_ClosingTransaction_to_counterparty_value_sat(uint64_t this_arg) {
39733 LDKClosingTransaction this_arg_conv;
39734 this_arg_conv.inner = untag_ptr(this_arg);
39735 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39737 this_arg_conv.is_owned = false;
39738 int64_t ret_conv = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
39742 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_holder_script"))) TS_ClosingTransaction_to_holder_script(uint64_t this_arg) {
39743 LDKClosingTransaction this_arg_conv;
39744 this_arg_conv.inner = untag_ptr(this_arg);
39745 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39747 this_arg_conv.is_owned = false;
39748 LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
39749 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39750 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39754 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_counterparty_script"))) TS_ClosingTransaction_to_counterparty_script(uint64_t this_arg) {
39755 LDKClosingTransaction this_arg_conv;
39756 this_arg_conv.inner = untag_ptr(this_arg);
39757 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39758 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39759 this_arg_conv.is_owned = false;
39760 LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
39761 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39762 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39766 void __attribute__((export_name("TS_TrustedClosingTransaction_free"))) TS_TrustedClosingTransaction_free(uint64_t this_obj) {
39767 LDKTrustedClosingTransaction this_obj_conv;
39768 this_obj_conv.inner = untag_ptr(this_obj);
39769 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39771 TrustedClosingTransaction_free(this_obj_conv);
39774 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_built_transaction"))) TS_TrustedClosingTransaction_built_transaction(uint64_t this_arg) {
39775 LDKTrustedClosingTransaction this_arg_conv;
39776 this_arg_conv.inner = untag_ptr(this_arg);
39777 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39779 this_arg_conv.is_owned = false;
39780 LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
39781 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39782 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39783 Transaction_free(ret_var);
39787 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) {
39788 LDKTrustedClosingTransaction this_arg_conv;
39789 this_arg_conv.inner = untag_ptr(this_arg);
39790 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39792 this_arg_conv.is_owned = false;
39793 LDKu8slice funding_redeemscript_ref;
39794 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39795 funding_redeemscript_ref.data = funding_redeemscript->elems;
39796 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39797 memcpy(ret_arr->elems, TrustedClosingTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
39798 FREE(funding_redeemscript);
39802 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) {
39803 LDKTrustedClosingTransaction this_arg_conv;
39804 this_arg_conv.inner = untag_ptr(this_arg);
39805 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39807 this_arg_conv.is_owned = false;
39808 uint8_t funding_key_arr[32];
39809 CHECK(funding_key->arr_len == 32);
39810 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39811 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
39812 LDKu8slice funding_redeemscript_ref;
39813 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39814 funding_redeemscript_ref.data = funding_redeemscript->elems;
39815 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39816 memcpy(ret_arr->elems, TrustedClosingTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
39817 FREE(funding_redeemscript);
39821 void __attribute__((export_name("TS_CommitmentTransaction_free"))) TS_CommitmentTransaction_free(uint64_t this_obj) {
39822 LDKCommitmentTransaction this_obj_conv;
39823 this_obj_conv.inner = untag_ptr(this_obj);
39824 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39826 CommitmentTransaction_free(this_obj_conv);
39829 static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
39830 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
39831 uint64_t ret_ref = 0;
39832 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39833 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39836 int64_t __attribute__((export_name("TS_CommitmentTransaction_clone_ptr"))) TS_CommitmentTransaction_clone_ptr(uint64_t arg) {
39837 LDKCommitmentTransaction arg_conv;
39838 arg_conv.inner = untag_ptr(arg);
39839 arg_conv.is_owned = ptr_is_owned(arg);
39840 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39841 arg_conv.is_owned = false;
39842 int64_t ret_conv = CommitmentTransaction_clone_ptr(&arg_conv);
39846 uint64_t __attribute__((export_name("TS_CommitmentTransaction_clone"))) TS_CommitmentTransaction_clone(uint64_t orig) {
39847 LDKCommitmentTransaction orig_conv;
39848 orig_conv.inner = untag_ptr(orig);
39849 orig_conv.is_owned = ptr_is_owned(orig);
39850 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39851 orig_conv.is_owned = false;
39852 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
39853 uint64_t ret_ref = 0;
39854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39855 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39859 int8_tArray __attribute__((export_name("TS_CommitmentTransaction_write"))) TS_CommitmentTransaction_write(uint64_t obj) {
39860 LDKCommitmentTransaction obj_conv;
39861 obj_conv.inner = untag_ptr(obj);
39862 obj_conv.is_owned = ptr_is_owned(obj);
39863 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39864 obj_conv.is_owned = false;
39865 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
39866 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39867 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39868 CVec_u8Z_free(ret_var);
39872 uint64_t __attribute__((export_name("TS_CommitmentTransaction_read"))) TS_CommitmentTransaction_read(int8_tArray ser) {
39873 LDKu8slice ser_ref;
39874 ser_ref.datalen = ser->arr_len;
39875 ser_ref.data = ser->elems;
39876 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
39877 *ret_conv = CommitmentTransaction_read(ser_ref);
39879 return tag_ptr(ret_conv, true);
39882 int64_t __attribute__((export_name("TS_CommitmentTransaction_commitment_number"))) TS_CommitmentTransaction_commitment_number(uint64_t this_arg) {
39883 LDKCommitmentTransaction this_arg_conv;
39884 this_arg_conv.inner = untag_ptr(this_arg);
39885 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39887 this_arg_conv.is_owned = false;
39888 int64_t ret_conv = CommitmentTransaction_commitment_number(&this_arg_conv);
39892 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_broadcaster_value_sat"))) TS_CommitmentTransaction_to_broadcaster_value_sat(uint64_t this_arg) {
39893 LDKCommitmentTransaction this_arg_conv;
39894 this_arg_conv.inner = untag_ptr(this_arg);
39895 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39897 this_arg_conv.is_owned = false;
39898 int64_t ret_conv = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
39902 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_countersignatory_value_sat"))) TS_CommitmentTransaction_to_countersignatory_value_sat(uint64_t this_arg) {
39903 LDKCommitmentTransaction this_arg_conv;
39904 this_arg_conv.inner = untag_ptr(this_arg);
39905 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39907 this_arg_conv.is_owned = false;
39908 int64_t ret_conv = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
39912 int32_t __attribute__((export_name("TS_CommitmentTransaction_feerate_per_kw"))) TS_CommitmentTransaction_feerate_per_kw(uint64_t this_arg) {
39913 LDKCommitmentTransaction this_arg_conv;
39914 this_arg_conv.inner = untag_ptr(this_arg);
39915 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39917 this_arg_conv.is_owned = false;
39918 int32_t ret_conv = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
39922 uint64_t __attribute__((export_name("TS_CommitmentTransaction_trust"))) TS_CommitmentTransaction_trust(uint64_t this_arg) {
39923 LDKCommitmentTransaction this_arg_conv;
39924 this_arg_conv.inner = untag_ptr(this_arg);
39925 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39926 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39927 this_arg_conv.is_owned = false;
39928 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
39929 uint64_t ret_ref = 0;
39930 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39931 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39935 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) {
39936 LDKCommitmentTransaction this_arg_conv;
39937 this_arg_conv.inner = untag_ptr(this_arg);
39938 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39939 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39940 this_arg_conv.is_owned = false;
39941 LDKDirectedChannelTransactionParameters channel_parameters_conv;
39942 channel_parameters_conv.inner = untag_ptr(channel_parameters);
39943 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
39944 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
39945 channel_parameters_conv.is_owned = false;
39946 LDKChannelPublicKeys broadcaster_keys_conv;
39947 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
39948 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
39949 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
39950 broadcaster_keys_conv.is_owned = false;
39951 LDKChannelPublicKeys countersignatory_keys_conv;
39952 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
39953 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
39954 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
39955 countersignatory_keys_conv.is_owned = false;
39956 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
39957 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
39958 return tag_ptr(ret_conv, true);
39961 void __attribute__((export_name("TS_TrustedCommitmentTransaction_free"))) TS_TrustedCommitmentTransaction_free(uint64_t this_obj) {
39962 LDKTrustedCommitmentTransaction this_obj_conv;
39963 this_obj_conv.inner = untag_ptr(this_obj);
39964 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39966 TrustedCommitmentTransaction_free(this_obj_conv);
39969 int8_tArray __attribute__((export_name("TS_TrustedCommitmentTransaction_txid"))) TS_TrustedCommitmentTransaction_txid(uint64_t this_arg) {
39970 LDKTrustedCommitmentTransaction this_arg_conv;
39971 this_arg_conv.inner = untag_ptr(this_arg);
39972 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39974 this_arg_conv.is_owned = false;
39975 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39976 memcpy(ret_arr->elems, TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
39980 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_built_transaction"))) TS_TrustedCommitmentTransaction_built_transaction(uint64_t this_arg) {
39981 LDKTrustedCommitmentTransaction this_arg_conv;
39982 this_arg_conv.inner = untag_ptr(this_arg);
39983 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39985 this_arg_conv.is_owned = false;
39986 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
39987 uint64_t ret_ref = 0;
39988 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39989 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39993 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_keys"))) TS_TrustedCommitmentTransaction_keys(uint64_t this_arg) {
39994 LDKTrustedCommitmentTransaction 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 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
40000 uint64_t ret_ref = 0;
40001 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40002 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40006 jboolean __attribute__((export_name("TS_TrustedCommitmentTransaction_opt_anchors"))) TS_TrustedCommitmentTransaction_opt_anchors(uint64_t this_arg) {
40007 LDKTrustedCommitmentTransaction this_arg_conv;
40008 this_arg_conv.inner = untag_ptr(this_arg);
40009 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40011 this_arg_conv.is_owned = false;
40012 jboolean ret_conv = TrustedCommitmentTransaction_opt_anchors(&this_arg_conv);
40016 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, uint64_t entropy_source) {
40017 LDKTrustedCommitmentTransaction this_arg_conv;
40018 this_arg_conv.inner = untag_ptr(this_arg);
40019 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40021 this_arg_conv.is_owned = false;
40022 uint8_t htlc_base_key_arr[32];
40023 CHECK(htlc_base_key->arr_len == 32);
40024 memcpy(htlc_base_key_arr, htlc_base_key->elems, 32); FREE(htlc_base_key);
40025 uint8_t (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
40026 LDKDirectedChannelTransactionParameters channel_parameters_conv;
40027 channel_parameters_conv.inner = untag_ptr(channel_parameters);
40028 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
40029 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
40030 channel_parameters_conv.is_owned = false;
40031 void* entropy_source_ptr = untag_ptr(entropy_source);
40032 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
40033 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
40034 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
40035 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv, entropy_source_conv);
40036 return tag_ptr(ret_conv, true);
40039 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) {
40040 LDKPublicKey broadcaster_payment_basepoint_ref;
40041 CHECK(broadcaster_payment_basepoint->arr_len == 33);
40042 memcpy(broadcaster_payment_basepoint_ref.compressed_form, broadcaster_payment_basepoint->elems, 33); FREE(broadcaster_payment_basepoint);
40043 LDKPublicKey countersignatory_payment_basepoint_ref;
40044 CHECK(countersignatory_payment_basepoint->arr_len == 33);
40045 memcpy(countersignatory_payment_basepoint_ref.compressed_form, countersignatory_payment_basepoint->elems, 33); FREE(countersignatory_payment_basepoint);
40046 int64_t ret_conv = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
40050 jboolean __attribute__((export_name("TS_InitFeatures_eq"))) TS_InitFeatures_eq(uint64_t a, uint64_t b) {
40051 LDKInitFeatures a_conv;
40052 a_conv.inner = untag_ptr(a);
40053 a_conv.is_owned = ptr_is_owned(a);
40054 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40055 a_conv.is_owned = false;
40056 LDKInitFeatures b_conv;
40057 b_conv.inner = untag_ptr(b);
40058 b_conv.is_owned = ptr_is_owned(b);
40059 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40060 b_conv.is_owned = false;
40061 jboolean ret_conv = InitFeatures_eq(&a_conv, &b_conv);
40065 jboolean __attribute__((export_name("TS_NodeFeatures_eq"))) TS_NodeFeatures_eq(uint64_t a, uint64_t b) {
40066 LDKNodeFeatures a_conv;
40067 a_conv.inner = untag_ptr(a);
40068 a_conv.is_owned = ptr_is_owned(a);
40069 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40070 a_conv.is_owned = false;
40071 LDKNodeFeatures b_conv;
40072 b_conv.inner = untag_ptr(b);
40073 b_conv.is_owned = ptr_is_owned(b);
40074 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40075 b_conv.is_owned = false;
40076 jboolean ret_conv = NodeFeatures_eq(&a_conv, &b_conv);
40080 jboolean __attribute__((export_name("TS_ChannelFeatures_eq"))) TS_ChannelFeatures_eq(uint64_t a, uint64_t b) {
40081 LDKChannelFeatures a_conv;
40082 a_conv.inner = untag_ptr(a);
40083 a_conv.is_owned = ptr_is_owned(a);
40084 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40085 a_conv.is_owned = false;
40086 LDKChannelFeatures b_conv;
40087 b_conv.inner = untag_ptr(b);
40088 b_conv.is_owned = ptr_is_owned(b);
40089 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40090 b_conv.is_owned = false;
40091 jboolean ret_conv = ChannelFeatures_eq(&a_conv, &b_conv);
40095 jboolean __attribute__((export_name("TS_InvoiceFeatures_eq"))) TS_InvoiceFeatures_eq(uint64_t a, uint64_t b) {
40096 LDKInvoiceFeatures a_conv;
40097 a_conv.inner = untag_ptr(a);
40098 a_conv.is_owned = ptr_is_owned(a);
40099 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40100 a_conv.is_owned = false;
40101 LDKInvoiceFeatures b_conv;
40102 b_conv.inner = untag_ptr(b);
40103 b_conv.is_owned = ptr_is_owned(b);
40104 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40105 b_conv.is_owned = false;
40106 jboolean ret_conv = InvoiceFeatures_eq(&a_conv, &b_conv);
40110 jboolean __attribute__((export_name("TS_OfferFeatures_eq"))) TS_OfferFeatures_eq(uint64_t a, uint64_t b) {
40111 LDKOfferFeatures a_conv;
40112 a_conv.inner = untag_ptr(a);
40113 a_conv.is_owned = ptr_is_owned(a);
40114 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40115 a_conv.is_owned = false;
40116 LDKOfferFeatures b_conv;
40117 b_conv.inner = untag_ptr(b);
40118 b_conv.is_owned = ptr_is_owned(b);
40119 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40120 b_conv.is_owned = false;
40121 jboolean ret_conv = OfferFeatures_eq(&a_conv, &b_conv);
40125 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_eq"))) TS_InvoiceRequestFeatures_eq(uint64_t a, uint64_t b) {
40126 LDKInvoiceRequestFeatures a_conv;
40127 a_conv.inner = untag_ptr(a);
40128 a_conv.is_owned = ptr_is_owned(a);
40129 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40130 a_conv.is_owned = false;
40131 LDKInvoiceRequestFeatures b_conv;
40132 b_conv.inner = untag_ptr(b);
40133 b_conv.is_owned = ptr_is_owned(b);
40134 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40135 b_conv.is_owned = false;
40136 jboolean ret_conv = InvoiceRequestFeatures_eq(&a_conv, &b_conv);
40140 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_eq"))) TS_Bolt12InvoiceFeatures_eq(uint64_t a, uint64_t b) {
40141 LDKBolt12InvoiceFeatures a_conv;
40142 a_conv.inner = untag_ptr(a);
40143 a_conv.is_owned = ptr_is_owned(a);
40144 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40145 a_conv.is_owned = false;
40146 LDKBolt12InvoiceFeatures b_conv;
40147 b_conv.inner = untag_ptr(b);
40148 b_conv.is_owned = ptr_is_owned(b);
40149 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40150 b_conv.is_owned = false;
40151 jboolean ret_conv = Bolt12InvoiceFeatures_eq(&a_conv, &b_conv);
40155 jboolean __attribute__((export_name("TS_BlindedHopFeatures_eq"))) TS_BlindedHopFeatures_eq(uint64_t a, uint64_t b) {
40156 LDKBlindedHopFeatures a_conv;
40157 a_conv.inner = untag_ptr(a);
40158 a_conv.is_owned = ptr_is_owned(a);
40159 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40160 a_conv.is_owned = false;
40161 LDKBlindedHopFeatures b_conv;
40162 b_conv.inner = untag_ptr(b);
40163 b_conv.is_owned = ptr_is_owned(b);
40164 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40165 b_conv.is_owned = false;
40166 jboolean ret_conv = BlindedHopFeatures_eq(&a_conv, &b_conv);
40170 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_eq"))) TS_ChannelTypeFeatures_eq(uint64_t a, uint64_t b) {
40171 LDKChannelTypeFeatures a_conv;
40172 a_conv.inner = untag_ptr(a);
40173 a_conv.is_owned = ptr_is_owned(a);
40174 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40175 a_conv.is_owned = false;
40176 LDKChannelTypeFeatures b_conv;
40177 b_conv.inner = untag_ptr(b);
40178 b_conv.is_owned = ptr_is_owned(b);
40179 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40180 b_conv.is_owned = false;
40181 jboolean ret_conv = ChannelTypeFeatures_eq(&a_conv, &b_conv);
40185 static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
40186 LDKInitFeatures ret_var = InitFeatures_clone(arg);
40187 uint64_t ret_ref = 0;
40188 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40189 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40192 int64_t __attribute__((export_name("TS_InitFeatures_clone_ptr"))) TS_InitFeatures_clone_ptr(uint64_t arg) {
40193 LDKInitFeatures arg_conv;
40194 arg_conv.inner = untag_ptr(arg);
40195 arg_conv.is_owned = ptr_is_owned(arg);
40196 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40197 arg_conv.is_owned = false;
40198 int64_t ret_conv = InitFeatures_clone_ptr(&arg_conv);
40202 uint64_t __attribute__((export_name("TS_InitFeatures_clone"))) TS_InitFeatures_clone(uint64_t orig) {
40203 LDKInitFeatures orig_conv;
40204 orig_conv.inner = untag_ptr(orig);
40205 orig_conv.is_owned = ptr_is_owned(orig);
40206 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40207 orig_conv.is_owned = false;
40208 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
40209 uint64_t ret_ref = 0;
40210 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40211 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40215 static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
40216 LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
40217 uint64_t ret_ref = 0;
40218 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40219 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40222 int64_t __attribute__((export_name("TS_NodeFeatures_clone_ptr"))) TS_NodeFeatures_clone_ptr(uint64_t arg) {
40223 LDKNodeFeatures arg_conv;
40224 arg_conv.inner = untag_ptr(arg);
40225 arg_conv.is_owned = ptr_is_owned(arg);
40226 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40227 arg_conv.is_owned = false;
40228 int64_t ret_conv = NodeFeatures_clone_ptr(&arg_conv);
40232 uint64_t __attribute__((export_name("TS_NodeFeatures_clone"))) TS_NodeFeatures_clone(uint64_t orig) {
40233 LDKNodeFeatures orig_conv;
40234 orig_conv.inner = untag_ptr(orig);
40235 orig_conv.is_owned = ptr_is_owned(orig);
40236 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40237 orig_conv.is_owned = false;
40238 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
40239 uint64_t ret_ref = 0;
40240 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40241 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40245 static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
40246 LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
40247 uint64_t ret_ref = 0;
40248 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40249 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40252 int64_t __attribute__((export_name("TS_ChannelFeatures_clone_ptr"))) TS_ChannelFeatures_clone_ptr(uint64_t arg) {
40253 LDKChannelFeatures arg_conv;
40254 arg_conv.inner = untag_ptr(arg);
40255 arg_conv.is_owned = ptr_is_owned(arg);
40256 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40257 arg_conv.is_owned = false;
40258 int64_t ret_conv = ChannelFeatures_clone_ptr(&arg_conv);
40262 uint64_t __attribute__((export_name("TS_ChannelFeatures_clone"))) TS_ChannelFeatures_clone(uint64_t orig) {
40263 LDKChannelFeatures orig_conv;
40264 orig_conv.inner = untag_ptr(orig);
40265 orig_conv.is_owned = ptr_is_owned(orig);
40266 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40267 orig_conv.is_owned = false;
40268 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
40269 uint64_t ret_ref = 0;
40270 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40271 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40275 static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
40276 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
40277 uint64_t ret_ref = 0;
40278 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40279 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40282 int64_t __attribute__((export_name("TS_InvoiceFeatures_clone_ptr"))) TS_InvoiceFeatures_clone_ptr(uint64_t arg) {
40283 LDKInvoiceFeatures arg_conv;
40284 arg_conv.inner = untag_ptr(arg);
40285 arg_conv.is_owned = ptr_is_owned(arg);
40286 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40287 arg_conv.is_owned = false;
40288 int64_t ret_conv = InvoiceFeatures_clone_ptr(&arg_conv);
40292 uint64_t __attribute__((export_name("TS_InvoiceFeatures_clone"))) TS_InvoiceFeatures_clone(uint64_t orig) {
40293 LDKInvoiceFeatures orig_conv;
40294 orig_conv.inner = untag_ptr(orig);
40295 orig_conv.is_owned = ptr_is_owned(orig);
40296 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40297 orig_conv.is_owned = false;
40298 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
40299 uint64_t ret_ref = 0;
40300 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40301 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40305 static inline uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg) {
40306 LDKOfferFeatures ret_var = OfferFeatures_clone(arg);
40307 uint64_t ret_ref = 0;
40308 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40309 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40312 int64_t __attribute__((export_name("TS_OfferFeatures_clone_ptr"))) TS_OfferFeatures_clone_ptr(uint64_t arg) {
40313 LDKOfferFeatures arg_conv;
40314 arg_conv.inner = untag_ptr(arg);
40315 arg_conv.is_owned = ptr_is_owned(arg);
40316 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40317 arg_conv.is_owned = false;
40318 int64_t ret_conv = OfferFeatures_clone_ptr(&arg_conv);
40322 uint64_t __attribute__((export_name("TS_OfferFeatures_clone"))) TS_OfferFeatures_clone(uint64_t orig) {
40323 LDKOfferFeatures orig_conv;
40324 orig_conv.inner = untag_ptr(orig);
40325 orig_conv.is_owned = ptr_is_owned(orig);
40326 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40327 orig_conv.is_owned = false;
40328 LDKOfferFeatures ret_var = OfferFeatures_clone(&orig_conv);
40329 uint64_t ret_ref = 0;
40330 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40331 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40335 static inline uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg) {
40336 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(arg);
40337 uint64_t ret_ref = 0;
40338 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40339 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40342 int64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone_ptr"))) TS_InvoiceRequestFeatures_clone_ptr(uint64_t arg) {
40343 LDKInvoiceRequestFeatures arg_conv;
40344 arg_conv.inner = untag_ptr(arg);
40345 arg_conv.is_owned = ptr_is_owned(arg);
40346 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40347 arg_conv.is_owned = false;
40348 int64_t ret_conv = InvoiceRequestFeatures_clone_ptr(&arg_conv);
40352 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone"))) TS_InvoiceRequestFeatures_clone(uint64_t orig) {
40353 LDKInvoiceRequestFeatures orig_conv;
40354 orig_conv.inner = untag_ptr(orig);
40355 orig_conv.is_owned = ptr_is_owned(orig);
40356 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40357 orig_conv.is_owned = false;
40358 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(&orig_conv);
40359 uint64_t ret_ref = 0;
40360 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40361 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40365 static inline uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg) {
40366 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_clone(arg);
40367 uint64_t ret_ref = 0;
40368 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40369 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40372 int64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_clone_ptr"))) TS_Bolt12InvoiceFeatures_clone_ptr(uint64_t arg) {
40373 LDKBolt12InvoiceFeatures arg_conv;
40374 arg_conv.inner = untag_ptr(arg);
40375 arg_conv.is_owned = ptr_is_owned(arg);
40376 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40377 arg_conv.is_owned = false;
40378 int64_t ret_conv = Bolt12InvoiceFeatures_clone_ptr(&arg_conv);
40382 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_clone"))) TS_Bolt12InvoiceFeatures_clone(uint64_t orig) {
40383 LDKBolt12InvoiceFeatures orig_conv;
40384 orig_conv.inner = untag_ptr(orig);
40385 orig_conv.is_owned = ptr_is_owned(orig);
40386 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40387 orig_conv.is_owned = false;
40388 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_clone(&orig_conv);
40389 uint64_t ret_ref = 0;
40390 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40391 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40395 static inline uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg) {
40396 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_clone(arg);
40397 uint64_t ret_ref = 0;
40398 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40399 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40402 int64_t __attribute__((export_name("TS_BlindedHopFeatures_clone_ptr"))) TS_BlindedHopFeatures_clone_ptr(uint64_t arg) {
40403 LDKBlindedHopFeatures arg_conv;
40404 arg_conv.inner = untag_ptr(arg);
40405 arg_conv.is_owned = ptr_is_owned(arg);
40406 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40407 arg_conv.is_owned = false;
40408 int64_t ret_conv = BlindedHopFeatures_clone_ptr(&arg_conv);
40412 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_clone"))) TS_BlindedHopFeatures_clone(uint64_t orig) {
40413 LDKBlindedHopFeatures orig_conv;
40414 orig_conv.inner = untag_ptr(orig);
40415 orig_conv.is_owned = ptr_is_owned(orig);
40416 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40417 orig_conv.is_owned = false;
40418 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_clone(&orig_conv);
40419 uint64_t ret_ref = 0;
40420 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40421 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40425 static inline uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg) {
40426 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(arg);
40427 uint64_t ret_ref = 0;
40428 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40429 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40432 int64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone_ptr"))) TS_ChannelTypeFeatures_clone_ptr(uint64_t arg) {
40433 LDKChannelTypeFeatures arg_conv;
40434 arg_conv.inner = untag_ptr(arg);
40435 arg_conv.is_owned = ptr_is_owned(arg);
40436 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40437 arg_conv.is_owned = false;
40438 int64_t ret_conv = ChannelTypeFeatures_clone_ptr(&arg_conv);
40442 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone"))) TS_ChannelTypeFeatures_clone(uint64_t orig) {
40443 LDKChannelTypeFeatures orig_conv;
40444 orig_conv.inner = untag_ptr(orig);
40445 orig_conv.is_owned = ptr_is_owned(orig);
40446 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40447 orig_conv.is_owned = false;
40448 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(&orig_conv);
40449 uint64_t ret_ref = 0;
40450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40451 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40455 void __attribute__((export_name("TS_InitFeatures_free"))) TS_InitFeatures_free(uint64_t this_obj) {
40456 LDKInitFeatures this_obj_conv;
40457 this_obj_conv.inner = untag_ptr(this_obj);
40458 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40460 InitFeatures_free(this_obj_conv);
40463 void __attribute__((export_name("TS_NodeFeatures_free"))) TS_NodeFeatures_free(uint64_t this_obj) {
40464 LDKNodeFeatures this_obj_conv;
40465 this_obj_conv.inner = untag_ptr(this_obj);
40466 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40468 NodeFeatures_free(this_obj_conv);
40471 void __attribute__((export_name("TS_ChannelFeatures_free"))) TS_ChannelFeatures_free(uint64_t this_obj) {
40472 LDKChannelFeatures this_obj_conv;
40473 this_obj_conv.inner = untag_ptr(this_obj);
40474 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40476 ChannelFeatures_free(this_obj_conv);
40479 void __attribute__((export_name("TS_InvoiceFeatures_free"))) TS_InvoiceFeatures_free(uint64_t this_obj) {
40480 LDKInvoiceFeatures this_obj_conv;
40481 this_obj_conv.inner = untag_ptr(this_obj);
40482 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40484 InvoiceFeatures_free(this_obj_conv);
40487 void __attribute__((export_name("TS_OfferFeatures_free"))) TS_OfferFeatures_free(uint64_t this_obj) {
40488 LDKOfferFeatures this_obj_conv;
40489 this_obj_conv.inner = untag_ptr(this_obj);
40490 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40492 OfferFeatures_free(this_obj_conv);
40495 void __attribute__((export_name("TS_InvoiceRequestFeatures_free"))) TS_InvoiceRequestFeatures_free(uint64_t this_obj) {
40496 LDKInvoiceRequestFeatures this_obj_conv;
40497 this_obj_conv.inner = untag_ptr(this_obj);
40498 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40499 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40500 InvoiceRequestFeatures_free(this_obj_conv);
40503 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_free"))) TS_Bolt12InvoiceFeatures_free(uint64_t this_obj) {
40504 LDKBolt12InvoiceFeatures this_obj_conv;
40505 this_obj_conv.inner = untag_ptr(this_obj);
40506 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40507 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40508 Bolt12InvoiceFeatures_free(this_obj_conv);
40511 void __attribute__((export_name("TS_BlindedHopFeatures_free"))) TS_BlindedHopFeatures_free(uint64_t this_obj) {
40512 LDKBlindedHopFeatures this_obj_conv;
40513 this_obj_conv.inner = untag_ptr(this_obj);
40514 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40516 BlindedHopFeatures_free(this_obj_conv);
40519 void __attribute__((export_name("TS_ChannelTypeFeatures_free"))) TS_ChannelTypeFeatures_free(uint64_t this_obj) {
40520 LDKChannelTypeFeatures this_obj_conv;
40521 this_obj_conv.inner = untag_ptr(this_obj);
40522 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40523 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40524 ChannelTypeFeatures_free(this_obj_conv);
40527 uint64_t __attribute__((export_name("TS_InitFeatures_empty"))) TS_InitFeatures_empty() {
40528 LDKInitFeatures ret_var = InitFeatures_empty();
40529 uint64_t ret_ref = 0;
40530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40531 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40535 jboolean __attribute__((export_name("TS_InitFeatures_requires_unknown_bits"))) TS_InitFeatures_requires_unknown_bits(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 jboolean ret_conv = InitFeatures_requires_unknown_bits(&this_arg_conv);
40545 uint64_t __attribute__((export_name("TS_NodeFeatures_empty"))) TS_NodeFeatures_empty() {
40546 LDKNodeFeatures ret_var = NodeFeatures_empty();
40547 uint64_t ret_ref = 0;
40548 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40549 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40553 jboolean __attribute__((export_name("TS_NodeFeatures_requires_unknown_bits"))) TS_NodeFeatures_requires_unknown_bits(uint64_t this_arg) {
40554 LDKNodeFeatures 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 = NodeFeatures_requires_unknown_bits(&this_arg_conv);
40563 uint64_t __attribute__((export_name("TS_ChannelFeatures_empty"))) TS_ChannelFeatures_empty() {
40564 LDKChannelFeatures ret_var = ChannelFeatures_empty();
40565 uint64_t ret_ref = 0;
40566 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40567 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40571 jboolean __attribute__((export_name("TS_ChannelFeatures_requires_unknown_bits"))) TS_ChannelFeatures_requires_unknown_bits(uint64_t this_arg) {
40572 LDKChannelFeatures this_arg_conv;
40573 this_arg_conv.inner = untag_ptr(this_arg);
40574 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40576 this_arg_conv.is_owned = false;
40577 jboolean ret_conv = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
40581 uint64_t __attribute__((export_name("TS_InvoiceFeatures_empty"))) TS_InvoiceFeatures_empty() {
40582 LDKInvoiceFeatures ret_var = InvoiceFeatures_empty();
40583 uint64_t ret_ref = 0;
40584 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40585 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40589 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_unknown_bits"))) TS_InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
40590 LDKInvoiceFeatures this_arg_conv;
40591 this_arg_conv.inner = untag_ptr(this_arg);
40592 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40594 this_arg_conv.is_owned = false;
40595 jboolean ret_conv = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
40599 uint64_t __attribute__((export_name("TS_OfferFeatures_empty"))) TS_OfferFeatures_empty() {
40600 LDKOfferFeatures ret_var = OfferFeatures_empty();
40601 uint64_t ret_ref = 0;
40602 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40603 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40607 jboolean __attribute__((export_name("TS_OfferFeatures_requires_unknown_bits"))) TS_OfferFeatures_requires_unknown_bits(uint64_t this_arg) {
40608 LDKOfferFeatures this_arg_conv;
40609 this_arg_conv.inner = untag_ptr(this_arg);
40610 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40611 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40612 this_arg_conv.is_owned = false;
40613 jboolean ret_conv = OfferFeatures_requires_unknown_bits(&this_arg_conv);
40617 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_empty"))) TS_InvoiceRequestFeatures_empty() {
40618 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_empty();
40619 uint64_t ret_ref = 0;
40620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40625 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_requires_unknown_bits"))) TS_InvoiceRequestFeatures_requires_unknown_bits(uint64_t this_arg) {
40626 LDKInvoiceRequestFeatures this_arg_conv;
40627 this_arg_conv.inner = untag_ptr(this_arg);
40628 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40630 this_arg_conv.is_owned = false;
40631 jboolean ret_conv = InvoiceRequestFeatures_requires_unknown_bits(&this_arg_conv);
40635 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_empty"))) TS_Bolt12InvoiceFeatures_empty() {
40636 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_empty();
40637 uint64_t ret_ref = 0;
40638 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40639 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40643 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_unknown_bits"))) TS_Bolt12InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
40644 LDKBolt12InvoiceFeatures this_arg_conv;
40645 this_arg_conv.inner = untag_ptr(this_arg);
40646 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40648 this_arg_conv.is_owned = false;
40649 jboolean ret_conv = Bolt12InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
40653 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_empty"))) TS_BlindedHopFeatures_empty() {
40654 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_empty();
40655 uint64_t ret_ref = 0;
40656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40657 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40661 jboolean __attribute__((export_name("TS_BlindedHopFeatures_requires_unknown_bits"))) TS_BlindedHopFeatures_requires_unknown_bits(uint64_t this_arg) {
40662 LDKBlindedHopFeatures this_arg_conv;
40663 this_arg_conv.inner = untag_ptr(this_arg);
40664 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40666 this_arg_conv.is_owned = false;
40667 jboolean ret_conv = BlindedHopFeatures_requires_unknown_bits(&this_arg_conv);
40671 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_empty"))) TS_ChannelTypeFeatures_empty() {
40672 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_empty();
40673 uint64_t ret_ref = 0;
40674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40675 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40679 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_unknown_bits"))) TS_ChannelTypeFeatures_requires_unknown_bits(uint64_t this_arg) {
40680 LDKChannelTypeFeatures this_arg_conv;
40681 this_arg_conv.inner = untag_ptr(this_arg);
40682 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40683 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40684 this_arg_conv.is_owned = false;
40685 jboolean ret_conv = ChannelTypeFeatures_requires_unknown_bits(&this_arg_conv);
40689 int8_tArray __attribute__((export_name("TS_InitFeatures_write"))) TS_InitFeatures_write(uint64_t obj) {
40690 LDKInitFeatures obj_conv;
40691 obj_conv.inner = untag_ptr(obj);
40692 obj_conv.is_owned = ptr_is_owned(obj);
40693 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40694 obj_conv.is_owned = false;
40695 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
40696 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40697 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40698 CVec_u8Z_free(ret_var);
40702 uint64_t __attribute__((export_name("TS_InitFeatures_read"))) TS_InitFeatures_read(int8_tArray ser) {
40703 LDKu8slice ser_ref;
40704 ser_ref.datalen = ser->arr_len;
40705 ser_ref.data = ser->elems;
40706 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
40707 *ret_conv = InitFeatures_read(ser_ref);
40709 return tag_ptr(ret_conv, true);
40712 int8_tArray __attribute__((export_name("TS_ChannelFeatures_write"))) TS_ChannelFeatures_write(uint64_t obj) {
40713 LDKChannelFeatures obj_conv;
40714 obj_conv.inner = untag_ptr(obj);
40715 obj_conv.is_owned = ptr_is_owned(obj);
40716 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40717 obj_conv.is_owned = false;
40718 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
40719 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40720 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40721 CVec_u8Z_free(ret_var);
40725 uint64_t __attribute__((export_name("TS_ChannelFeatures_read"))) TS_ChannelFeatures_read(int8_tArray ser) {
40726 LDKu8slice ser_ref;
40727 ser_ref.datalen = ser->arr_len;
40728 ser_ref.data = ser->elems;
40729 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
40730 *ret_conv = ChannelFeatures_read(ser_ref);
40732 return tag_ptr(ret_conv, true);
40735 int8_tArray __attribute__((export_name("TS_NodeFeatures_write"))) TS_NodeFeatures_write(uint64_t obj) {
40736 LDKNodeFeatures obj_conv;
40737 obj_conv.inner = untag_ptr(obj);
40738 obj_conv.is_owned = ptr_is_owned(obj);
40739 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40740 obj_conv.is_owned = false;
40741 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
40742 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40743 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40744 CVec_u8Z_free(ret_var);
40748 uint64_t __attribute__((export_name("TS_NodeFeatures_read"))) TS_NodeFeatures_read(int8_tArray ser) {
40749 LDKu8slice ser_ref;
40750 ser_ref.datalen = ser->arr_len;
40751 ser_ref.data = ser->elems;
40752 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
40753 *ret_conv = NodeFeatures_read(ser_ref);
40755 return tag_ptr(ret_conv, true);
40758 int8_tArray __attribute__((export_name("TS_InvoiceFeatures_write"))) TS_InvoiceFeatures_write(uint64_t obj) {
40759 LDKInvoiceFeatures obj_conv;
40760 obj_conv.inner = untag_ptr(obj);
40761 obj_conv.is_owned = ptr_is_owned(obj);
40762 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40763 obj_conv.is_owned = false;
40764 LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
40765 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40766 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40767 CVec_u8Z_free(ret_var);
40771 uint64_t __attribute__((export_name("TS_InvoiceFeatures_read"))) TS_InvoiceFeatures_read(int8_tArray ser) {
40772 LDKu8slice ser_ref;
40773 ser_ref.datalen = ser->arr_len;
40774 ser_ref.data = ser->elems;
40775 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
40776 *ret_conv = InvoiceFeatures_read(ser_ref);
40778 return tag_ptr(ret_conv, true);
40781 int8_tArray __attribute__((export_name("TS_BlindedHopFeatures_write"))) TS_BlindedHopFeatures_write(uint64_t obj) {
40782 LDKBlindedHopFeatures obj_conv;
40783 obj_conv.inner = untag_ptr(obj);
40784 obj_conv.is_owned = ptr_is_owned(obj);
40785 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40786 obj_conv.is_owned = false;
40787 LDKCVec_u8Z ret_var = BlindedHopFeatures_write(&obj_conv);
40788 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40789 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40790 CVec_u8Z_free(ret_var);
40794 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_read"))) TS_BlindedHopFeatures_read(int8_tArray ser) {
40795 LDKu8slice ser_ref;
40796 ser_ref.datalen = ser->arr_len;
40797 ser_ref.data = ser->elems;
40798 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
40799 *ret_conv = BlindedHopFeatures_read(ser_ref);
40801 return tag_ptr(ret_conv, true);
40804 int8_tArray __attribute__((export_name("TS_ChannelTypeFeatures_write"))) TS_ChannelTypeFeatures_write(uint64_t obj) {
40805 LDKChannelTypeFeatures obj_conv;
40806 obj_conv.inner = untag_ptr(obj);
40807 obj_conv.is_owned = ptr_is_owned(obj);
40808 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40809 obj_conv.is_owned = false;
40810 LDKCVec_u8Z ret_var = ChannelTypeFeatures_write(&obj_conv);
40811 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40812 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40813 CVec_u8Z_free(ret_var);
40817 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_read"))) TS_ChannelTypeFeatures_read(int8_tArray ser) {
40818 LDKu8slice ser_ref;
40819 ser_ref.datalen = ser->arr_len;
40820 ser_ref.data = ser->elems;
40821 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
40822 *ret_conv = ChannelTypeFeatures_read(ser_ref);
40824 return tag_ptr(ret_conv, true);
40827 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_optional"))) TS_InitFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
40828 LDKInitFeatures this_arg_conv;
40829 this_arg_conv.inner = untag_ptr(this_arg);
40830 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40832 this_arg_conv.is_owned = false;
40833 InitFeatures_set_data_loss_protect_optional(&this_arg_conv);
40836 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_required"))) TS_InitFeatures_set_data_loss_protect_required(uint64_t this_arg) {
40837 LDKInitFeatures this_arg_conv;
40838 this_arg_conv.inner = untag_ptr(this_arg);
40839 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40840 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40841 this_arg_conv.is_owned = false;
40842 InitFeatures_set_data_loss_protect_required(&this_arg_conv);
40845 jboolean __attribute__((export_name("TS_InitFeatures_supports_data_loss_protect"))) TS_InitFeatures_supports_data_loss_protect(uint64_t this_arg) {
40846 LDKInitFeatures this_arg_conv;
40847 this_arg_conv.inner = untag_ptr(this_arg);
40848 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40849 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40850 this_arg_conv.is_owned = false;
40851 jboolean ret_conv = InitFeatures_supports_data_loss_protect(&this_arg_conv);
40855 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_optional"))) TS_NodeFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
40856 LDKNodeFeatures this_arg_conv;
40857 this_arg_conv.inner = untag_ptr(this_arg);
40858 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40860 this_arg_conv.is_owned = false;
40861 NodeFeatures_set_data_loss_protect_optional(&this_arg_conv);
40864 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_required"))) TS_NodeFeatures_set_data_loss_protect_required(uint64_t this_arg) {
40865 LDKNodeFeatures this_arg_conv;
40866 this_arg_conv.inner = untag_ptr(this_arg);
40867 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40868 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40869 this_arg_conv.is_owned = false;
40870 NodeFeatures_set_data_loss_protect_required(&this_arg_conv);
40873 jboolean __attribute__((export_name("TS_NodeFeatures_supports_data_loss_protect"))) TS_NodeFeatures_supports_data_loss_protect(uint64_t this_arg) {
40874 LDKNodeFeatures this_arg_conv;
40875 this_arg_conv.inner = untag_ptr(this_arg);
40876 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40878 this_arg_conv.is_owned = false;
40879 jboolean ret_conv = NodeFeatures_supports_data_loss_protect(&this_arg_conv);
40883 jboolean __attribute__((export_name("TS_InitFeatures_requires_data_loss_protect"))) TS_InitFeatures_requires_data_loss_protect(uint64_t this_arg) {
40884 LDKInitFeatures this_arg_conv;
40885 this_arg_conv.inner = untag_ptr(this_arg);
40886 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40888 this_arg_conv.is_owned = false;
40889 jboolean ret_conv = InitFeatures_requires_data_loss_protect(&this_arg_conv);
40893 jboolean __attribute__((export_name("TS_NodeFeatures_requires_data_loss_protect"))) TS_NodeFeatures_requires_data_loss_protect(uint64_t this_arg) {
40894 LDKNodeFeatures this_arg_conv;
40895 this_arg_conv.inner = untag_ptr(this_arg);
40896 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40898 this_arg_conv.is_owned = false;
40899 jboolean ret_conv = NodeFeatures_requires_data_loss_protect(&this_arg_conv);
40903 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_optional"))) TS_InitFeatures_set_initial_routing_sync_optional(uint64_t this_arg) {
40904 LDKInitFeatures this_arg_conv;
40905 this_arg_conv.inner = untag_ptr(this_arg);
40906 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40907 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40908 this_arg_conv.is_owned = false;
40909 InitFeatures_set_initial_routing_sync_optional(&this_arg_conv);
40912 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_required"))) TS_InitFeatures_set_initial_routing_sync_required(uint64_t this_arg) {
40913 LDKInitFeatures this_arg_conv;
40914 this_arg_conv.inner = untag_ptr(this_arg);
40915 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40917 this_arg_conv.is_owned = false;
40918 InitFeatures_set_initial_routing_sync_required(&this_arg_conv);
40921 jboolean __attribute__((export_name("TS_InitFeatures_initial_routing_sync"))) TS_InitFeatures_initial_routing_sync(uint64_t this_arg) {
40922 LDKInitFeatures this_arg_conv;
40923 this_arg_conv.inner = untag_ptr(this_arg);
40924 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40926 this_arg_conv.is_owned = false;
40927 jboolean ret_conv = InitFeatures_initial_routing_sync(&this_arg_conv);
40931 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_optional"))) TS_InitFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
40932 LDKInitFeatures this_arg_conv;
40933 this_arg_conv.inner = untag_ptr(this_arg);
40934 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40936 this_arg_conv.is_owned = false;
40937 InitFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
40940 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_required"))) TS_InitFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
40941 LDKInitFeatures this_arg_conv;
40942 this_arg_conv.inner = untag_ptr(this_arg);
40943 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40945 this_arg_conv.is_owned = false;
40946 InitFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
40949 jboolean __attribute__((export_name("TS_InitFeatures_supports_upfront_shutdown_script"))) TS_InitFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
40950 LDKInitFeatures this_arg_conv;
40951 this_arg_conv.inner = untag_ptr(this_arg);
40952 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40954 this_arg_conv.is_owned = false;
40955 jboolean ret_conv = InitFeatures_supports_upfront_shutdown_script(&this_arg_conv);
40959 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_optional"))) TS_NodeFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
40960 LDKNodeFeatures this_arg_conv;
40961 this_arg_conv.inner = untag_ptr(this_arg);
40962 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40964 this_arg_conv.is_owned = false;
40965 NodeFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
40968 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_required"))) TS_NodeFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
40969 LDKNodeFeatures this_arg_conv;
40970 this_arg_conv.inner = untag_ptr(this_arg);
40971 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40972 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40973 this_arg_conv.is_owned = false;
40974 NodeFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
40977 jboolean __attribute__((export_name("TS_NodeFeatures_supports_upfront_shutdown_script"))) TS_NodeFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
40978 LDKNodeFeatures this_arg_conv;
40979 this_arg_conv.inner = untag_ptr(this_arg);
40980 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40982 this_arg_conv.is_owned = false;
40983 jboolean ret_conv = NodeFeatures_supports_upfront_shutdown_script(&this_arg_conv);
40987 jboolean __attribute__((export_name("TS_InitFeatures_requires_upfront_shutdown_script"))) TS_InitFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
40988 LDKInitFeatures this_arg_conv;
40989 this_arg_conv.inner = untag_ptr(this_arg);
40990 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40992 this_arg_conv.is_owned = false;
40993 jboolean ret_conv = InitFeatures_requires_upfront_shutdown_script(&this_arg_conv);
40997 jboolean __attribute__((export_name("TS_NodeFeatures_requires_upfront_shutdown_script"))) TS_NodeFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
40998 LDKNodeFeatures this_arg_conv;
40999 this_arg_conv.inner = untag_ptr(this_arg);
41000 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41002 this_arg_conv.is_owned = false;
41003 jboolean ret_conv = NodeFeatures_requires_upfront_shutdown_script(&this_arg_conv);
41007 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_optional"))) TS_InitFeatures_set_gossip_queries_optional(uint64_t this_arg) {
41008 LDKInitFeatures this_arg_conv;
41009 this_arg_conv.inner = untag_ptr(this_arg);
41010 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41012 this_arg_conv.is_owned = false;
41013 InitFeatures_set_gossip_queries_optional(&this_arg_conv);
41016 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_required"))) TS_InitFeatures_set_gossip_queries_required(uint64_t this_arg) {
41017 LDKInitFeatures this_arg_conv;
41018 this_arg_conv.inner = untag_ptr(this_arg);
41019 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41021 this_arg_conv.is_owned = false;
41022 InitFeatures_set_gossip_queries_required(&this_arg_conv);
41025 jboolean __attribute__((export_name("TS_InitFeatures_supports_gossip_queries"))) TS_InitFeatures_supports_gossip_queries(uint64_t this_arg) {
41026 LDKInitFeatures this_arg_conv;
41027 this_arg_conv.inner = untag_ptr(this_arg);
41028 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41030 this_arg_conv.is_owned = false;
41031 jboolean ret_conv = InitFeatures_supports_gossip_queries(&this_arg_conv);
41035 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_optional"))) TS_NodeFeatures_set_gossip_queries_optional(uint64_t this_arg) {
41036 LDKNodeFeatures this_arg_conv;
41037 this_arg_conv.inner = untag_ptr(this_arg);
41038 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41040 this_arg_conv.is_owned = false;
41041 NodeFeatures_set_gossip_queries_optional(&this_arg_conv);
41044 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_required"))) TS_NodeFeatures_set_gossip_queries_required(uint64_t this_arg) {
41045 LDKNodeFeatures this_arg_conv;
41046 this_arg_conv.inner = untag_ptr(this_arg);
41047 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41048 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41049 this_arg_conv.is_owned = false;
41050 NodeFeatures_set_gossip_queries_required(&this_arg_conv);
41053 jboolean __attribute__((export_name("TS_NodeFeatures_supports_gossip_queries"))) TS_NodeFeatures_supports_gossip_queries(uint64_t this_arg) {
41054 LDKNodeFeatures this_arg_conv;
41055 this_arg_conv.inner = untag_ptr(this_arg);
41056 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41058 this_arg_conv.is_owned = false;
41059 jboolean ret_conv = NodeFeatures_supports_gossip_queries(&this_arg_conv);
41063 jboolean __attribute__((export_name("TS_InitFeatures_requires_gossip_queries"))) TS_InitFeatures_requires_gossip_queries(uint64_t this_arg) {
41064 LDKInitFeatures this_arg_conv;
41065 this_arg_conv.inner = untag_ptr(this_arg);
41066 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41068 this_arg_conv.is_owned = false;
41069 jboolean ret_conv = InitFeatures_requires_gossip_queries(&this_arg_conv);
41073 jboolean __attribute__((export_name("TS_NodeFeatures_requires_gossip_queries"))) TS_NodeFeatures_requires_gossip_queries(uint64_t this_arg) {
41074 LDKNodeFeatures this_arg_conv;
41075 this_arg_conv.inner = untag_ptr(this_arg);
41076 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41077 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41078 this_arg_conv.is_owned = false;
41079 jboolean ret_conv = NodeFeatures_requires_gossip_queries(&this_arg_conv);
41083 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_optional"))) TS_InitFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
41084 LDKInitFeatures this_arg_conv;
41085 this_arg_conv.inner = untag_ptr(this_arg);
41086 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41087 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41088 this_arg_conv.is_owned = false;
41089 InitFeatures_set_variable_length_onion_optional(&this_arg_conv);
41092 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_required"))) TS_InitFeatures_set_variable_length_onion_required(uint64_t this_arg) {
41093 LDKInitFeatures this_arg_conv;
41094 this_arg_conv.inner = untag_ptr(this_arg);
41095 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41096 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41097 this_arg_conv.is_owned = false;
41098 InitFeatures_set_variable_length_onion_required(&this_arg_conv);
41101 jboolean __attribute__((export_name("TS_InitFeatures_supports_variable_length_onion"))) TS_InitFeatures_supports_variable_length_onion(uint64_t this_arg) {
41102 LDKInitFeatures this_arg_conv;
41103 this_arg_conv.inner = untag_ptr(this_arg);
41104 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41106 this_arg_conv.is_owned = false;
41107 jboolean ret_conv = InitFeatures_supports_variable_length_onion(&this_arg_conv);
41111 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_optional"))) TS_NodeFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
41112 LDKNodeFeatures this_arg_conv;
41113 this_arg_conv.inner = untag_ptr(this_arg);
41114 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41116 this_arg_conv.is_owned = false;
41117 NodeFeatures_set_variable_length_onion_optional(&this_arg_conv);
41120 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_required"))) TS_NodeFeatures_set_variable_length_onion_required(uint64_t this_arg) {
41121 LDKNodeFeatures this_arg_conv;
41122 this_arg_conv.inner = untag_ptr(this_arg);
41123 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41124 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41125 this_arg_conv.is_owned = false;
41126 NodeFeatures_set_variable_length_onion_required(&this_arg_conv);
41129 jboolean __attribute__((export_name("TS_NodeFeatures_supports_variable_length_onion"))) TS_NodeFeatures_supports_variable_length_onion(uint64_t this_arg) {
41130 LDKNodeFeatures this_arg_conv;
41131 this_arg_conv.inner = untag_ptr(this_arg);
41132 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41134 this_arg_conv.is_owned = false;
41135 jboolean ret_conv = NodeFeatures_supports_variable_length_onion(&this_arg_conv);
41139 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_optional"))) TS_InvoiceFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
41140 LDKInvoiceFeatures this_arg_conv;
41141 this_arg_conv.inner = untag_ptr(this_arg);
41142 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41144 this_arg_conv.is_owned = false;
41145 InvoiceFeatures_set_variable_length_onion_optional(&this_arg_conv);
41148 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_required"))) TS_InvoiceFeatures_set_variable_length_onion_required(uint64_t this_arg) {
41149 LDKInvoiceFeatures this_arg_conv;
41150 this_arg_conv.inner = untag_ptr(this_arg);
41151 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41152 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41153 this_arg_conv.is_owned = false;
41154 InvoiceFeatures_set_variable_length_onion_required(&this_arg_conv);
41157 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_variable_length_onion"))) TS_InvoiceFeatures_supports_variable_length_onion(uint64_t this_arg) {
41158 LDKInvoiceFeatures this_arg_conv;
41159 this_arg_conv.inner = untag_ptr(this_arg);
41160 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41162 this_arg_conv.is_owned = false;
41163 jboolean ret_conv = InvoiceFeatures_supports_variable_length_onion(&this_arg_conv);
41167 jboolean __attribute__((export_name("TS_InitFeatures_requires_variable_length_onion"))) TS_InitFeatures_requires_variable_length_onion(uint64_t this_arg) {
41168 LDKInitFeatures this_arg_conv;
41169 this_arg_conv.inner = untag_ptr(this_arg);
41170 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41172 this_arg_conv.is_owned = false;
41173 jboolean ret_conv = InitFeatures_requires_variable_length_onion(&this_arg_conv);
41177 jboolean __attribute__((export_name("TS_NodeFeatures_requires_variable_length_onion"))) TS_NodeFeatures_requires_variable_length_onion(uint64_t this_arg) {
41178 LDKNodeFeatures this_arg_conv;
41179 this_arg_conv.inner = untag_ptr(this_arg);
41180 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41181 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41182 this_arg_conv.is_owned = false;
41183 jboolean ret_conv = NodeFeatures_requires_variable_length_onion(&this_arg_conv);
41187 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_variable_length_onion"))) TS_InvoiceFeatures_requires_variable_length_onion(uint64_t this_arg) {
41188 LDKInvoiceFeatures this_arg_conv;
41189 this_arg_conv.inner = untag_ptr(this_arg);
41190 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41191 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41192 this_arg_conv.is_owned = false;
41193 jboolean ret_conv = InvoiceFeatures_requires_variable_length_onion(&this_arg_conv);
41197 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_optional"))) TS_InitFeatures_set_static_remote_key_optional(uint64_t this_arg) {
41198 LDKInitFeatures this_arg_conv;
41199 this_arg_conv.inner = untag_ptr(this_arg);
41200 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41201 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41202 this_arg_conv.is_owned = false;
41203 InitFeatures_set_static_remote_key_optional(&this_arg_conv);
41206 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_required"))) TS_InitFeatures_set_static_remote_key_required(uint64_t this_arg) {
41207 LDKInitFeatures this_arg_conv;
41208 this_arg_conv.inner = untag_ptr(this_arg);
41209 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41211 this_arg_conv.is_owned = false;
41212 InitFeatures_set_static_remote_key_required(&this_arg_conv);
41215 jboolean __attribute__((export_name("TS_InitFeatures_supports_static_remote_key"))) TS_InitFeatures_supports_static_remote_key(uint64_t this_arg) {
41216 LDKInitFeatures this_arg_conv;
41217 this_arg_conv.inner = untag_ptr(this_arg);
41218 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41220 this_arg_conv.is_owned = false;
41221 jboolean ret_conv = InitFeatures_supports_static_remote_key(&this_arg_conv);
41225 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_optional"))) TS_NodeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
41226 LDKNodeFeatures this_arg_conv;
41227 this_arg_conv.inner = untag_ptr(this_arg);
41228 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41230 this_arg_conv.is_owned = false;
41231 NodeFeatures_set_static_remote_key_optional(&this_arg_conv);
41234 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_required"))) TS_NodeFeatures_set_static_remote_key_required(uint64_t this_arg) {
41235 LDKNodeFeatures this_arg_conv;
41236 this_arg_conv.inner = untag_ptr(this_arg);
41237 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41238 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41239 this_arg_conv.is_owned = false;
41240 NodeFeatures_set_static_remote_key_required(&this_arg_conv);
41243 jboolean __attribute__((export_name("TS_NodeFeatures_supports_static_remote_key"))) TS_NodeFeatures_supports_static_remote_key(uint64_t this_arg) {
41244 LDKNodeFeatures this_arg_conv;
41245 this_arg_conv.inner = untag_ptr(this_arg);
41246 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41248 this_arg_conv.is_owned = false;
41249 jboolean ret_conv = NodeFeatures_supports_static_remote_key(&this_arg_conv);
41253 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_optional"))) TS_ChannelTypeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
41254 LDKChannelTypeFeatures this_arg_conv;
41255 this_arg_conv.inner = untag_ptr(this_arg);
41256 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41258 this_arg_conv.is_owned = false;
41259 ChannelTypeFeatures_set_static_remote_key_optional(&this_arg_conv);
41262 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_required"))) TS_ChannelTypeFeatures_set_static_remote_key_required(uint64_t this_arg) {
41263 LDKChannelTypeFeatures this_arg_conv;
41264 this_arg_conv.inner = untag_ptr(this_arg);
41265 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41266 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41267 this_arg_conv.is_owned = false;
41268 ChannelTypeFeatures_set_static_remote_key_required(&this_arg_conv);
41271 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_static_remote_key"))) TS_ChannelTypeFeatures_supports_static_remote_key(uint64_t this_arg) {
41272 LDKChannelTypeFeatures this_arg_conv;
41273 this_arg_conv.inner = untag_ptr(this_arg);
41274 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41276 this_arg_conv.is_owned = false;
41277 jboolean ret_conv = ChannelTypeFeatures_supports_static_remote_key(&this_arg_conv);
41281 jboolean __attribute__((export_name("TS_InitFeatures_requires_static_remote_key"))) TS_InitFeatures_requires_static_remote_key(uint64_t this_arg) {
41282 LDKInitFeatures this_arg_conv;
41283 this_arg_conv.inner = untag_ptr(this_arg);
41284 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41285 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41286 this_arg_conv.is_owned = false;
41287 jboolean ret_conv = InitFeatures_requires_static_remote_key(&this_arg_conv);
41291 jboolean __attribute__((export_name("TS_NodeFeatures_requires_static_remote_key"))) TS_NodeFeatures_requires_static_remote_key(uint64_t this_arg) {
41292 LDKNodeFeatures this_arg_conv;
41293 this_arg_conv.inner = untag_ptr(this_arg);
41294 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41295 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41296 this_arg_conv.is_owned = false;
41297 jboolean ret_conv = NodeFeatures_requires_static_remote_key(&this_arg_conv);
41301 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_static_remote_key"))) TS_ChannelTypeFeatures_requires_static_remote_key(uint64_t this_arg) {
41302 LDKChannelTypeFeatures this_arg_conv;
41303 this_arg_conv.inner = untag_ptr(this_arg);
41304 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41306 this_arg_conv.is_owned = false;
41307 jboolean ret_conv = ChannelTypeFeatures_requires_static_remote_key(&this_arg_conv);
41311 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_optional"))) TS_InitFeatures_set_payment_secret_optional(uint64_t this_arg) {
41312 LDKInitFeatures this_arg_conv;
41313 this_arg_conv.inner = untag_ptr(this_arg);
41314 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41316 this_arg_conv.is_owned = false;
41317 InitFeatures_set_payment_secret_optional(&this_arg_conv);
41320 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_required"))) TS_InitFeatures_set_payment_secret_required(uint64_t this_arg) {
41321 LDKInitFeatures this_arg_conv;
41322 this_arg_conv.inner = untag_ptr(this_arg);
41323 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41325 this_arg_conv.is_owned = false;
41326 InitFeatures_set_payment_secret_required(&this_arg_conv);
41329 jboolean __attribute__((export_name("TS_InitFeatures_supports_payment_secret"))) TS_InitFeatures_supports_payment_secret(uint64_t this_arg) {
41330 LDKInitFeatures this_arg_conv;
41331 this_arg_conv.inner = untag_ptr(this_arg);
41332 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41333 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41334 this_arg_conv.is_owned = false;
41335 jboolean ret_conv = InitFeatures_supports_payment_secret(&this_arg_conv);
41339 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_optional"))) TS_NodeFeatures_set_payment_secret_optional(uint64_t this_arg) {
41340 LDKNodeFeatures this_arg_conv;
41341 this_arg_conv.inner = untag_ptr(this_arg);
41342 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41344 this_arg_conv.is_owned = false;
41345 NodeFeatures_set_payment_secret_optional(&this_arg_conv);
41348 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_required"))) TS_NodeFeatures_set_payment_secret_required(uint64_t this_arg) {
41349 LDKNodeFeatures this_arg_conv;
41350 this_arg_conv.inner = untag_ptr(this_arg);
41351 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41353 this_arg_conv.is_owned = false;
41354 NodeFeatures_set_payment_secret_required(&this_arg_conv);
41357 jboolean __attribute__((export_name("TS_NodeFeatures_supports_payment_secret"))) TS_NodeFeatures_supports_payment_secret(uint64_t this_arg) {
41358 LDKNodeFeatures this_arg_conv;
41359 this_arg_conv.inner = untag_ptr(this_arg);
41360 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41361 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41362 this_arg_conv.is_owned = false;
41363 jboolean ret_conv = NodeFeatures_supports_payment_secret(&this_arg_conv);
41367 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_optional"))) TS_InvoiceFeatures_set_payment_secret_optional(uint64_t this_arg) {
41368 LDKInvoiceFeatures this_arg_conv;
41369 this_arg_conv.inner = untag_ptr(this_arg);
41370 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41372 this_arg_conv.is_owned = false;
41373 InvoiceFeatures_set_payment_secret_optional(&this_arg_conv);
41376 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_required"))) TS_InvoiceFeatures_set_payment_secret_required(uint64_t this_arg) {
41377 LDKInvoiceFeatures this_arg_conv;
41378 this_arg_conv.inner = untag_ptr(this_arg);
41379 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41380 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41381 this_arg_conv.is_owned = false;
41382 InvoiceFeatures_set_payment_secret_required(&this_arg_conv);
41385 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_payment_secret"))) TS_InvoiceFeatures_supports_payment_secret(uint64_t this_arg) {
41386 LDKInvoiceFeatures this_arg_conv;
41387 this_arg_conv.inner = untag_ptr(this_arg);
41388 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41390 this_arg_conv.is_owned = false;
41391 jboolean ret_conv = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
41395 jboolean __attribute__((export_name("TS_InitFeatures_requires_payment_secret"))) TS_InitFeatures_requires_payment_secret(uint64_t this_arg) {
41396 LDKInitFeatures this_arg_conv;
41397 this_arg_conv.inner = untag_ptr(this_arg);
41398 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41400 this_arg_conv.is_owned = false;
41401 jboolean ret_conv = InitFeatures_requires_payment_secret(&this_arg_conv);
41405 jboolean __attribute__((export_name("TS_NodeFeatures_requires_payment_secret"))) TS_NodeFeatures_requires_payment_secret(uint64_t this_arg) {
41406 LDKNodeFeatures 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.is_owned = false;
41411 jboolean ret_conv = NodeFeatures_requires_payment_secret(&this_arg_conv);
41415 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_payment_secret"))) TS_InvoiceFeatures_requires_payment_secret(uint64_t this_arg) {
41416 LDKInvoiceFeatures this_arg_conv;
41417 this_arg_conv.inner = untag_ptr(this_arg);
41418 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41419 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41420 this_arg_conv.is_owned = false;
41421 jboolean ret_conv = InvoiceFeatures_requires_payment_secret(&this_arg_conv);
41425 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_optional"))) TS_InitFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41426 LDKInitFeatures this_arg_conv;
41427 this_arg_conv.inner = untag_ptr(this_arg);
41428 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41429 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41430 this_arg_conv.is_owned = false;
41431 InitFeatures_set_basic_mpp_optional(&this_arg_conv);
41434 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_required"))) TS_InitFeatures_set_basic_mpp_required(uint64_t this_arg) {
41435 LDKInitFeatures this_arg_conv;
41436 this_arg_conv.inner = untag_ptr(this_arg);
41437 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41439 this_arg_conv.is_owned = false;
41440 InitFeatures_set_basic_mpp_required(&this_arg_conv);
41443 jboolean __attribute__((export_name("TS_InitFeatures_supports_basic_mpp"))) TS_InitFeatures_supports_basic_mpp(uint64_t this_arg) {
41444 LDKInitFeatures this_arg_conv;
41445 this_arg_conv.inner = untag_ptr(this_arg);
41446 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41447 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41448 this_arg_conv.is_owned = false;
41449 jboolean ret_conv = InitFeatures_supports_basic_mpp(&this_arg_conv);
41453 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_optional"))) TS_NodeFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41454 LDKNodeFeatures this_arg_conv;
41455 this_arg_conv.inner = untag_ptr(this_arg);
41456 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41458 this_arg_conv.is_owned = false;
41459 NodeFeatures_set_basic_mpp_optional(&this_arg_conv);
41462 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_required"))) TS_NodeFeatures_set_basic_mpp_required(uint64_t this_arg) {
41463 LDKNodeFeatures this_arg_conv;
41464 this_arg_conv.inner = untag_ptr(this_arg);
41465 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41467 this_arg_conv.is_owned = false;
41468 NodeFeatures_set_basic_mpp_required(&this_arg_conv);
41471 jboolean __attribute__((export_name("TS_NodeFeatures_supports_basic_mpp"))) TS_NodeFeatures_supports_basic_mpp(uint64_t this_arg) {
41472 LDKNodeFeatures this_arg_conv;
41473 this_arg_conv.inner = untag_ptr(this_arg);
41474 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41476 this_arg_conv.is_owned = false;
41477 jboolean ret_conv = NodeFeatures_supports_basic_mpp(&this_arg_conv);
41481 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_optional"))) TS_InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41482 LDKInvoiceFeatures this_arg_conv;
41483 this_arg_conv.inner = untag_ptr(this_arg);
41484 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41485 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41486 this_arg_conv.is_owned = false;
41487 InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
41490 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_required"))) TS_InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
41491 LDKInvoiceFeatures this_arg_conv;
41492 this_arg_conv.inner = untag_ptr(this_arg);
41493 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41495 this_arg_conv.is_owned = false;
41496 InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
41499 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_basic_mpp"))) TS_InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
41500 LDKInvoiceFeatures this_arg_conv;
41501 this_arg_conv.inner = untag_ptr(this_arg);
41502 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41504 this_arg_conv.is_owned = false;
41505 jboolean ret_conv = InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
41509 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_basic_mpp_optional"))) TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41510 LDKBolt12InvoiceFeatures this_arg_conv;
41511 this_arg_conv.inner = untag_ptr(this_arg);
41512 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41514 this_arg_conv.is_owned = false;
41515 Bolt12InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
41518 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_basic_mpp_required"))) TS_Bolt12InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
41519 LDKBolt12InvoiceFeatures this_arg_conv;
41520 this_arg_conv.inner = untag_ptr(this_arg);
41521 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41523 this_arg_conv.is_owned = false;
41524 Bolt12InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
41527 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_supports_basic_mpp"))) TS_Bolt12InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
41528 LDKBolt12InvoiceFeatures this_arg_conv;
41529 this_arg_conv.inner = untag_ptr(this_arg);
41530 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41531 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41532 this_arg_conv.is_owned = false;
41533 jboolean ret_conv = Bolt12InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
41537 jboolean __attribute__((export_name("TS_InitFeatures_requires_basic_mpp"))) TS_InitFeatures_requires_basic_mpp(uint64_t this_arg) {
41538 LDKInitFeatures this_arg_conv;
41539 this_arg_conv.inner = untag_ptr(this_arg);
41540 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41542 this_arg_conv.is_owned = false;
41543 jboolean ret_conv = InitFeatures_requires_basic_mpp(&this_arg_conv);
41547 jboolean __attribute__((export_name("TS_NodeFeatures_requires_basic_mpp"))) TS_NodeFeatures_requires_basic_mpp(uint64_t this_arg) {
41548 LDKNodeFeatures this_arg_conv;
41549 this_arg_conv.inner = untag_ptr(this_arg);
41550 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41551 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41552 this_arg_conv.is_owned = false;
41553 jboolean ret_conv = NodeFeatures_requires_basic_mpp(&this_arg_conv);
41557 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_basic_mpp"))) TS_InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
41558 LDKInvoiceFeatures this_arg_conv;
41559 this_arg_conv.inner = untag_ptr(this_arg);
41560 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41561 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41562 this_arg_conv.is_owned = false;
41563 jboolean ret_conv = InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
41567 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_basic_mpp"))) TS_Bolt12InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
41568 LDKBolt12InvoiceFeatures this_arg_conv;
41569 this_arg_conv.inner = untag_ptr(this_arg);
41570 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41572 this_arg_conv.is_owned = false;
41573 jboolean ret_conv = Bolt12InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
41577 void __attribute__((export_name("TS_InitFeatures_set_wumbo_optional"))) TS_InitFeatures_set_wumbo_optional(uint64_t this_arg) {
41578 LDKInitFeatures this_arg_conv;
41579 this_arg_conv.inner = untag_ptr(this_arg);
41580 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41582 this_arg_conv.is_owned = false;
41583 InitFeatures_set_wumbo_optional(&this_arg_conv);
41586 void __attribute__((export_name("TS_InitFeatures_set_wumbo_required"))) TS_InitFeatures_set_wumbo_required(uint64_t this_arg) {
41587 LDKInitFeatures this_arg_conv;
41588 this_arg_conv.inner = untag_ptr(this_arg);
41589 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41590 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41591 this_arg_conv.is_owned = false;
41592 InitFeatures_set_wumbo_required(&this_arg_conv);
41595 jboolean __attribute__((export_name("TS_InitFeatures_supports_wumbo"))) TS_InitFeatures_supports_wumbo(uint64_t this_arg) {
41596 LDKInitFeatures this_arg_conv;
41597 this_arg_conv.inner = untag_ptr(this_arg);
41598 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41599 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41600 this_arg_conv.is_owned = false;
41601 jboolean ret_conv = InitFeatures_supports_wumbo(&this_arg_conv);
41605 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_optional"))) TS_NodeFeatures_set_wumbo_optional(uint64_t this_arg) {
41606 LDKNodeFeatures this_arg_conv;
41607 this_arg_conv.inner = untag_ptr(this_arg);
41608 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41609 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41610 this_arg_conv.is_owned = false;
41611 NodeFeatures_set_wumbo_optional(&this_arg_conv);
41614 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_required"))) TS_NodeFeatures_set_wumbo_required(uint64_t this_arg) {
41615 LDKNodeFeatures this_arg_conv;
41616 this_arg_conv.inner = untag_ptr(this_arg);
41617 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41618 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41619 this_arg_conv.is_owned = false;
41620 NodeFeatures_set_wumbo_required(&this_arg_conv);
41623 jboolean __attribute__((export_name("TS_NodeFeatures_supports_wumbo"))) TS_NodeFeatures_supports_wumbo(uint64_t this_arg) {
41624 LDKNodeFeatures this_arg_conv;
41625 this_arg_conv.inner = untag_ptr(this_arg);
41626 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41628 this_arg_conv.is_owned = false;
41629 jboolean ret_conv = NodeFeatures_supports_wumbo(&this_arg_conv);
41633 jboolean __attribute__((export_name("TS_InitFeatures_requires_wumbo"))) TS_InitFeatures_requires_wumbo(uint64_t this_arg) {
41634 LDKInitFeatures this_arg_conv;
41635 this_arg_conv.inner = untag_ptr(this_arg);
41636 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41637 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41638 this_arg_conv.is_owned = false;
41639 jboolean ret_conv = InitFeatures_requires_wumbo(&this_arg_conv);
41643 jboolean __attribute__((export_name("TS_NodeFeatures_requires_wumbo"))) TS_NodeFeatures_requires_wumbo(uint64_t this_arg) {
41644 LDKNodeFeatures this_arg_conv;
41645 this_arg_conv.inner = untag_ptr(this_arg);
41646 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41648 this_arg_conv.is_owned = false;
41649 jboolean ret_conv = NodeFeatures_requires_wumbo(&this_arg_conv);
41653 void __attribute__((export_name("TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional"))) TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(uint64_t this_arg) {
41654 LDKInitFeatures this_arg_conv;
41655 this_arg_conv.inner = untag_ptr(this_arg);
41656 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41658 this_arg_conv.is_owned = false;
41659 InitFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
41662 void __attribute__((export_name("TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required"))) TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(uint64_t this_arg) {
41663 LDKInitFeatures this_arg_conv;
41664 this_arg_conv.inner = untag_ptr(this_arg);
41665 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41667 this_arg_conv.is_owned = false;
41668 InitFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
41671 jboolean __attribute__((export_name("TS_InitFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41672 LDKInitFeatures this_arg_conv;
41673 this_arg_conv.inner = untag_ptr(this_arg);
41674 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41675 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41676 this_arg_conv.is_owned = false;
41677 jboolean ret_conv = InitFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
41681 void __attribute__((export_name("TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional"))) TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(uint64_t this_arg) {
41682 LDKNodeFeatures this_arg_conv;
41683 this_arg_conv.inner = untag_ptr(this_arg);
41684 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41686 this_arg_conv.is_owned = false;
41687 NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
41690 void __attribute__((export_name("TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required"))) TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(uint64_t this_arg) {
41691 LDKNodeFeatures this_arg_conv;
41692 this_arg_conv.inner = untag_ptr(this_arg);
41693 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41695 this_arg_conv.is_owned = false;
41696 NodeFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
41699 jboolean __attribute__((export_name("TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41700 LDKNodeFeatures this_arg_conv;
41701 this_arg_conv.inner = untag_ptr(this_arg);
41702 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41704 this_arg_conv.is_owned = false;
41705 jboolean ret_conv = NodeFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
41709 void __attribute__((export_name("TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional"))) TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(uint64_t this_arg) {
41710 LDKChannelTypeFeatures this_arg_conv;
41711 this_arg_conv.inner = untag_ptr(this_arg);
41712 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41713 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41714 this_arg_conv.is_owned = false;
41715 ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
41718 void __attribute__((export_name("TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required"))) TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(uint64_t this_arg) {
41719 LDKChannelTypeFeatures this_arg_conv;
41720 this_arg_conv.inner = untag_ptr(this_arg);
41721 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41723 this_arg_conv.is_owned = false;
41724 ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
41727 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41728 LDKChannelTypeFeatures this_arg_conv;
41729 this_arg_conv.inner = untag_ptr(this_arg);
41730 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41732 this_arg_conv.is_owned = false;
41733 jboolean ret_conv = ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
41737 jboolean __attribute__((export_name("TS_InitFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41738 LDKInitFeatures 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 jboolean ret_conv = InitFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
41747 jboolean __attribute__((export_name("TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41748 LDKNodeFeatures 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 jboolean ret_conv = NodeFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
41757 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41758 LDKChannelTypeFeatures this_arg_conv;
41759 this_arg_conv.inner = untag_ptr(this_arg);
41760 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41762 this_arg_conv.is_owned = false;
41763 jboolean ret_conv = ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
41767 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_optional"))) TS_InitFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
41768 LDKInitFeatures this_arg_conv;
41769 this_arg_conv.inner = untag_ptr(this_arg);
41770 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41772 this_arg_conv.is_owned = false;
41773 InitFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
41776 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_required"))) TS_InitFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
41777 LDKInitFeatures this_arg_conv;
41778 this_arg_conv.inner = untag_ptr(this_arg);
41779 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41781 this_arg_conv.is_owned = false;
41782 InitFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
41785 jboolean __attribute__((export_name("TS_InitFeatures_supports_shutdown_anysegwit"))) TS_InitFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
41786 LDKInitFeatures this_arg_conv;
41787 this_arg_conv.inner = untag_ptr(this_arg);
41788 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41790 this_arg_conv.is_owned = false;
41791 jboolean ret_conv = InitFeatures_supports_shutdown_anysegwit(&this_arg_conv);
41795 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_optional"))) TS_NodeFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
41796 LDKNodeFeatures this_arg_conv;
41797 this_arg_conv.inner = untag_ptr(this_arg);
41798 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41799 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41800 this_arg_conv.is_owned = false;
41801 NodeFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
41804 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_required"))) TS_NodeFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
41805 LDKNodeFeatures this_arg_conv;
41806 this_arg_conv.inner = untag_ptr(this_arg);
41807 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41809 this_arg_conv.is_owned = false;
41810 NodeFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
41813 jboolean __attribute__((export_name("TS_NodeFeatures_supports_shutdown_anysegwit"))) TS_NodeFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
41814 LDKNodeFeatures this_arg_conv;
41815 this_arg_conv.inner = untag_ptr(this_arg);
41816 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41818 this_arg_conv.is_owned = false;
41819 jboolean ret_conv = NodeFeatures_supports_shutdown_anysegwit(&this_arg_conv);
41823 jboolean __attribute__((export_name("TS_InitFeatures_requires_shutdown_anysegwit"))) TS_InitFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
41824 LDKInitFeatures this_arg_conv;
41825 this_arg_conv.inner = untag_ptr(this_arg);
41826 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41828 this_arg_conv.is_owned = false;
41829 jboolean ret_conv = InitFeatures_requires_shutdown_anysegwit(&this_arg_conv);
41833 jboolean __attribute__((export_name("TS_NodeFeatures_requires_shutdown_anysegwit"))) TS_NodeFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
41834 LDKNodeFeatures this_arg_conv;
41835 this_arg_conv.inner = untag_ptr(this_arg);
41836 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41837 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41838 this_arg_conv.is_owned = false;
41839 jboolean ret_conv = NodeFeatures_requires_shutdown_anysegwit(&this_arg_conv);
41843 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_optional"))) TS_InitFeatures_set_onion_messages_optional(uint64_t this_arg) {
41844 LDKInitFeatures this_arg_conv;
41845 this_arg_conv.inner = untag_ptr(this_arg);
41846 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41847 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41848 this_arg_conv.is_owned = false;
41849 InitFeatures_set_onion_messages_optional(&this_arg_conv);
41852 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_required"))) TS_InitFeatures_set_onion_messages_required(uint64_t this_arg) {
41853 LDKInitFeatures this_arg_conv;
41854 this_arg_conv.inner = untag_ptr(this_arg);
41855 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41857 this_arg_conv.is_owned = false;
41858 InitFeatures_set_onion_messages_required(&this_arg_conv);
41861 jboolean __attribute__((export_name("TS_InitFeatures_supports_onion_messages"))) TS_InitFeatures_supports_onion_messages(uint64_t this_arg) {
41862 LDKInitFeatures this_arg_conv;
41863 this_arg_conv.inner = untag_ptr(this_arg);
41864 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41866 this_arg_conv.is_owned = false;
41867 jboolean ret_conv = InitFeatures_supports_onion_messages(&this_arg_conv);
41871 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_optional"))) TS_NodeFeatures_set_onion_messages_optional(uint64_t this_arg) {
41872 LDKNodeFeatures this_arg_conv;
41873 this_arg_conv.inner = untag_ptr(this_arg);
41874 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41876 this_arg_conv.is_owned = false;
41877 NodeFeatures_set_onion_messages_optional(&this_arg_conv);
41880 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_required"))) TS_NodeFeatures_set_onion_messages_required(uint64_t this_arg) {
41881 LDKNodeFeatures this_arg_conv;
41882 this_arg_conv.inner = untag_ptr(this_arg);
41883 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41885 this_arg_conv.is_owned = false;
41886 NodeFeatures_set_onion_messages_required(&this_arg_conv);
41889 jboolean __attribute__((export_name("TS_NodeFeatures_supports_onion_messages"))) TS_NodeFeatures_supports_onion_messages(uint64_t this_arg) {
41890 LDKNodeFeatures this_arg_conv;
41891 this_arg_conv.inner = untag_ptr(this_arg);
41892 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41893 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41894 this_arg_conv.is_owned = false;
41895 jboolean ret_conv = NodeFeatures_supports_onion_messages(&this_arg_conv);
41899 jboolean __attribute__((export_name("TS_InitFeatures_requires_onion_messages"))) TS_InitFeatures_requires_onion_messages(uint64_t this_arg) {
41900 LDKInitFeatures this_arg_conv;
41901 this_arg_conv.inner = untag_ptr(this_arg);
41902 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41903 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41904 this_arg_conv.is_owned = false;
41905 jboolean ret_conv = InitFeatures_requires_onion_messages(&this_arg_conv);
41909 jboolean __attribute__((export_name("TS_NodeFeatures_requires_onion_messages"))) TS_NodeFeatures_requires_onion_messages(uint64_t this_arg) {
41910 LDKNodeFeatures this_arg_conv;
41911 this_arg_conv.inner = untag_ptr(this_arg);
41912 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41913 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41914 this_arg_conv.is_owned = false;
41915 jboolean ret_conv = NodeFeatures_requires_onion_messages(&this_arg_conv);
41919 void __attribute__((export_name("TS_InitFeatures_set_channel_type_optional"))) TS_InitFeatures_set_channel_type_optional(uint64_t this_arg) {
41920 LDKInitFeatures this_arg_conv;
41921 this_arg_conv.inner = untag_ptr(this_arg);
41922 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41923 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41924 this_arg_conv.is_owned = false;
41925 InitFeatures_set_channel_type_optional(&this_arg_conv);
41928 void __attribute__((export_name("TS_InitFeatures_set_channel_type_required"))) TS_InitFeatures_set_channel_type_required(uint64_t this_arg) {
41929 LDKInitFeatures this_arg_conv;
41930 this_arg_conv.inner = untag_ptr(this_arg);
41931 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41933 this_arg_conv.is_owned = false;
41934 InitFeatures_set_channel_type_required(&this_arg_conv);
41937 jboolean __attribute__((export_name("TS_InitFeatures_supports_channel_type"))) TS_InitFeatures_supports_channel_type(uint64_t this_arg) {
41938 LDKInitFeatures this_arg_conv;
41939 this_arg_conv.inner = untag_ptr(this_arg);
41940 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41942 this_arg_conv.is_owned = false;
41943 jboolean ret_conv = InitFeatures_supports_channel_type(&this_arg_conv);
41947 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_optional"))) TS_NodeFeatures_set_channel_type_optional(uint64_t this_arg) {
41948 LDKNodeFeatures this_arg_conv;
41949 this_arg_conv.inner = untag_ptr(this_arg);
41950 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41952 this_arg_conv.is_owned = false;
41953 NodeFeatures_set_channel_type_optional(&this_arg_conv);
41956 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_required"))) TS_NodeFeatures_set_channel_type_required(uint64_t this_arg) {
41957 LDKNodeFeatures this_arg_conv;
41958 this_arg_conv.inner = untag_ptr(this_arg);
41959 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41961 this_arg_conv.is_owned = false;
41962 NodeFeatures_set_channel_type_required(&this_arg_conv);
41965 jboolean __attribute__((export_name("TS_NodeFeatures_supports_channel_type"))) TS_NodeFeatures_supports_channel_type(uint64_t this_arg) {
41966 LDKNodeFeatures this_arg_conv;
41967 this_arg_conv.inner = untag_ptr(this_arg);
41968 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41970 this_arg_conv.is_owned = false;
41971 jboolean ret_conv = NodeFeatures_supports_channel_type(&this_arg_conv);
41975 jboolean __attribute__((export_name("TS_InitFeatures_requires_channel_type"))) TS_InitFeatures_requires_channel_type(uint64_t this_arg) {
41976 LDKInitFeatures this_arg_conv;
41977 this_arg_conv.inner = untag_ptr(this_arg);
41978 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41980 this_arg_conv.is_owned = false;
41981 jboolean ret_conv = InitFeatures_requires_channel_type(&this_arg_conv);
41985 jboolean __attribute__((export_name("TS_NodeFeatures_requires_channel_type"))) TS_NodeFeatures_requires_channel_type(uint64_t this_arg) {
41986 LDKNodeFeatures this_arg_conv;
41987 this_arg_conv.inner = untag_ptr(this_arg);
41988 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41990 this_arg_conv.is_owned = false;
41991 jboolean ret_conv = NodeFeatures_requires_channel_type(&this_arg_conv);
41995 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_optional"))) TS_InitFeatures_set_scid_privacy_optional(uint64_t this_arg) {
41996 LDKInitFeatures this_arg_conv;
41997 this_arg_conv.inner = untag_ptr(this_arg);
41998 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42000 this_arg_conv.is_owned = false;
42001 InitFeatures_set_scid_privacy_optional(&this_arg_conv);
42004 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_required"))) TS_InitFeatures_set_scid_privacy_required(uint64_t this_arg) {
42005 LDKInitFeatures this_arg_conv;
42006 this_arg_conv.inner = untag_ptr(this_arg);
42007 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42009 this_arg_conv.is_owned = false;
42010 InitFeatures_set_scid_privacy_required(&this_arg_conv);
42013 jboolean __attribute__((export_name("TS_InitFeatures_supports_scid_privacy"))) TS_InitFeatures_supports_scid_privacy(uint64_t this_arg) {
42014 LDKInitFeatures this_arg_conv;
42015 this_arg_conv.inner = untag_ptr(this_arg);
42016 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42018 this_arg_conv.is_owned = false;
42019 jboolean ret_conv = InitFeatures_supports_scid_privacy(&this_arg_conv);
42023 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_optional"))) TS_NodeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
42024 LDKNodeFeatures this_arg_conv;
42025 this_arg_conv.inner = untag_ptr(this_arg);
42026 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42028 this_arg_conv.is_owned = false;
42029 NodeFeatures_set_scid_privacy_optional(&this_arg_conv);
42032 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_required"))) TS_NodeFeatures_set_scid_privacy_required(uint64_t this_arg) {
42033 LDKNodeFeatures this_arg_conv;
42034 this_arg_conv.inner = untag_ptr(this_arg);
42035 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42037 this_arg_conv.is_owned = false;
42038 NodeFeatures_set_scid_privacy_required(&this_arg_conv);
42041 jboolean __attribute__((export_name("TS_NodeFeatures_supports_scid_privacy"))) TS_NodeFeatures_supports_scid_privacy(uint64_t this_arg) {
42042 LDKNodeFeatures this_arg_conv;
42043 this_arg_conv.inner = untag_ptr(this_arg);
42044 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42046 this_arg_conv.is_owned = false;
42047 jboolean ret_conv = NodeFeatures_supports_scid_privacy(&this_arg_conv);
42051 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_optional"))) TS_ChannelTypeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
42052 LDKChannelTypeFeatures this_arg_conv;
42053 this_arg_conv.inner = untag_ptr(this_arg);
42054 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42056 this_arg_conv.is_owned = false;
42057 ChannelTypeFeatures_set_scid_privacy_optional(&this_arg_conv);
42060 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_required"))) TS_ChannelTypeFeatures_set_scid_privacy_required(uint64_t this_arg) {
42061 LDKChannelTypeFeatures this_arg_conv;
42062 this_arg_conv.inner = untag_ptr(this_arg);
42063 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42064 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42065 this_arg_conv.is_owned = false;
42066 ChannelTypeFeatures_set_scid_privacy_required(&this_arg_conv);
42069 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_scid_privacy"))) TS_ChannelTypeFeatures_supports_scid_privacy(uint64_t this_arg) {
42070 LDKChannelTypeFeatures this_arg_conv;
42071 this_arg_conv.inner = untag_ptr(this_arg);
42072 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42073 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42074 this_arg_conv.is_owned = false;
42075 jboolean ret_conv = ChannelTypeFeatures_supports_scid_privacy(&this_arg_conv);
42079 jboolean __attribute__((export_name("TS_InitFeatures_requires_scid_privacy"))) TS_InitFeatures_requires_scid_privacy(uint64_t this_arg) {
42080 LDKInitFeatures this_arg_conv;
42081 this_arg_conv.inner = untag_ptr(this_arg);
42082 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42083 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42084 this_arg_conv.is_owned = false;
42085 jboolean ret_conv = InitFeatures_requires_scid_privacy(&this_arg_conv);
42089 jboolean __attribute__((export_name("TS_NodeFeatures_requires_scid_privacy"))) TS_NodeFeatures_requires_scid_privacy(uint64_t this_arg) {
42090 LDKNodeFeatures this_arg_conv;
42091 this_arg_conv.inner = untag_ptr(this_arg);
42092 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42093 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42094 this_arg_conv.is_owned = false;
42095 jboolean ret_conv = NodeFeatures_requires_scid_privacy(&this_arg_conv);
42099 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_scid_privacy"))) TS_ChannelTypeFeatures_requires_scid_privacy(uint64_t this_arg) {
42100 LDKChannelTypeFeatures this_arg_conv;
42101 this_arg_conv.inner = untag_ptr(this_arg);
42102 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42104 this_arg_conv.is_owned = false;
42105 jboolean ret_conv = ChannelTypeFeatures_requires_scid_privacy(&this_arg_conv);
42109 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_metadata_optional"))) TS_InvoiceFeatures_set_payment_metadata_optional(uint64_t this_arg) {
42110 LDKInvoiceFeatures this_arg_conv;
42111 this_arg_conv.inner = untag_ptr(this_arg);
42112 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42113 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42114 this_arg_conv.is_owned = false;
42115 InvoiceFeatures_set_payment_metadata_optional(&this_arg_conv);
42118 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_metadata_required"))) TS_InvoiceFeatures_set_payment_metadata_required(uint64_t this_arg) {
42119 LDKInvoiceFeatures this_arg_conv;
42120 this_arg_conv.inner = untag_ptr(this_arg);
42121 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42122 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42123 this_arg_conv.is_owned = false;
42124 InvoiceFeatures_set_payment_metadata_required(&this_arg_conv);
42127 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_payment_metadata"))) TS_InvoiceFeatures_supports_payment_metadata(uint64_t this_arg) {
42128 LDKInvoiceFeatures this_arg_conv;
42129 this_arg_conv.inner = untag_ptr(this_arg);
42130 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42132 this_arg_conv.is_owned = false;
42133 jboolean ret_conv = InvoiceFeatures_supports_payment_metadata(&this_arg_conv);
42137 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_payment_metadata"))) TS_InvoiceFeatures_requires_payment_metadata(uint64_t this_arg) {
42138 LDKInvoiceFeatures this_arg_conv;
42139 this_arg_conv.inner = untag_ptr(this_arg);
42140 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42142 this_arg_conv.is_owned = false;
42143 jboolean ret_conv = InvoiceFeatures_requires_payment_metadata(&this_arg_conv);
42147 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_optional"))) TS_InitFeatures_set_zero_conf_optional(uint64_t this_arg) {
42148 LDKInitFeatures this_arg_conv;
42149 this_arg_conv.inner = untag_ptr(this_arg);
42150 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42152 this_arg_conv.is_owned = false;
42153 InitFeatures_set_zero_conf_optional(&this_arg_conv);
42156 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_required"))) TS_InitFeatures_set_zero_conf_required(uint64_t this_arg) {
42157 LDKInitFeatures this_arg_conv;
42158 this_arg_conv.inner = untag_ptr(this_arg);
42159 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42160 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42161 this_arg_conv.is_owned = false;
42162 InitFeatures_set_zero_conf_required(&this_arg_conv);
42165 jboolean __attribute__((export_name("TS_InitFeatures_supports_zero_conf"))) TS_InitFeatures_supports_zero_conf(uint64_t this_arg) {
42166 LDKInitFeatures this_arg_conv;
42167 this_arg_conv.inner = untag_ptr(this_arg);
42168 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42170 this_arg_conv.is_owned = false;
42171 jboolean ret_conv = InitFeatures_supports_zero_conf(&this_arg_conv);
42175 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_optional"))) TS_NodeFeatures_set_zero_conf_optional(uint64_t this_arg) {
42176 LDKNodeFeatures this_arg_conv;
42177 this_arg_conv.inner = untag_ptr(this_arg);
42178 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42179 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42180 this_arg_conv.is_owned = false;
42181 NodeFeatures_set_zero_conf_optional(&this_arg_conv);
42184 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_required"))) TS_NodeFeatures_set_zero_conf_required(uint64_t this_arg) {
42185 LDKNodeFeatures this_arg_conv;
42186 this_arg_conv.inner = untag_ptr(this_arg);
42187 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42189 this_arg_conv.is_owned = false;
42190 NodeFeatures_set_zero_conf_required(&this_arg_conv);
42193 jboolean __attribute__((export_name("TS_NodeFeatures_supports_zero_conf"))) TS_NodeFeatures_supports_zero_conf(uint64_t this_arg) {
42194 LDKNodeFeatures this_arg_conv;
42195 this_arg_conv.inner = untag_ptr(this_arg);
42196 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42198 this_arg_conv.is_owned = false;
42199 jboolean ret_conv = NodeFeatures_supports_zero_conf(&this_arg_conv);
42203 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_optional"))) TS_ChannelTypeFeatures_set_zero_conf_optional(uint64_t this_arg) {
42204 LDKChannelTypeFeatures this_arg_conv;
42205 this_arg_conv.inner = untag_ptr(this_arg);
42206 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42208 this_arg_conv.is_owned = false;
42209 ChannelTypeFeatures_set_zero_conf_optional(&this_arg_conv);
42212 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_required"))) TS_ChannelTypeFeatures_set_zero_conf_required(uint64_t this_arg) {
42213 LDKChannelTypeFeatures this_arg_conv;
42214 this_arg_conv.inner = untag_ptr(this_arg);
42215 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42217 this_arg_conv.is_owned = false;
42218 ChannelTypeFeatures_set_zero_conf_required(&this_arg_conv);
42221 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_zero_conf"))) TS_ChannelTypeFeatures_supports_zero_conf(uint64_t this_arg) {
42222 LDKChannelTypeFeatures this_arg_conv;
42223 this_arg_conv.inner = untag_ptr(this_arg);
42224 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42226 this_arg_conv.is_owned = false;
42227 jboolean ret_conv = ChannelTypeFeatures_supports_zero_conf(&this_arg_conv);
42231 jboolean __attribute__((export_name("TS_InitFeatures_requires_zero_conf"))) TS_InitFeatures_requires_zero_conf(uint64_t this_arg) {
42232 LDKInitFeatures this_arg_conv;
42233 this_arg_conv.inner = untag_ptr(this_arg);
42234 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42235 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42236 this_arg_conv.is_owned = false;
42237 jboolean ret_conv = InitFeatures_requires_zero_conf(&this_arg_conv);
42241 jboolean __attribute__((export_name("TS_NodeFeatures_requires_zero_conf"))) TS_NodeFeatures_requires_zero_conf(uint64_t this_arg) {
42242 LDKNodeFeatures this_arg_conv;
42243 this_arg_conv.inner = untag_ptr(this_arg);
42244 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42246 this_arg_conv.is_owned = false;
42247 jboolean ret_conv = NodeFeatures_requires_zero_conf(&this_arg_conv);
42251 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_zero_conf"))) TS_ChannelTypeFeatures_requires_zero_conf(uint64_t this_arg) {
42252 LDKChannelTypeFeatures this_arg_conv;
42253 this_arg_conv.inner = untag_ptr(this_arg);
42254 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42256 this_arg_conv.is_owned = false;
42257 jboolean ret_conv = ChannelTypeFeatures_requires_zero_conf(&this_arg_conv);
42261 void __attribute__((export_name("TS_NodeFeatures_set_keysend_optional"))) TS_NodeFeatures_set_keysend_optional(uint64_t this_arg) {
42262 LDKNodeFeatures this_arg_conv;
42263 this_arg_conv.inner = untag_ptr(this_arg);
42264 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42266 this_arg_conv.is_owned = false;
42267 NodeFeatures_set_keysend_optional(&this_arg_conv);
42270 void __attribute__((export_name("TS_NodeFeatures_set_keysend_required"))) TS_NodeFeatures_set_keysend_required(uint64_t this_arg) {
42271 LDKNodeFeatures this_arg_conv;
42272 this_arg_conv.inner = untag_ptr(this_arg);
42273 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42274 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42275 this_arg_conv.is_owned = false;
42276 NodeFeatures_set_keysend_required(&this_arg_conv);
42279 jboolean __attribute__((export_name("TS_NodeFeatures_supports_keysend"))) TS_NodeFeatures_supports_keysend(uint64_t this_arg) {
42280 LDKNodeFeatures this_arg_conv;
42281 this_arg_conv.inner = untag_ptr(this_arg);
42282 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42283 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42284 this_arg_conv.is_owned = false;
42285 jboolean ret_conv = NodeFeatures_supports_keysend(&this_arg_conv);
42289 jboolean __attribute__((export_name("TS_NodeFeatures_requires_keysend"))) TS_NodeFeatures_requires_keysend(uint64_t this_arg) {
42290 LDKNodeFeatures this_arg_conv;
42291 this_arg_conv.inner = untag_ptr(this_arg);
42292 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42294 this_arg_conv.is_owned = false;
42295 jboolean ret_conv = NodeFeatures_requires_keysend(&this_arg_conv);
42299 void __attribute__((export_name("TS_ShutdownScript_free"))) TS_ShutdownScript_free(uint64_t this_obj) {
42300 LDKShutdownScript this_obj_conv;
42301 this_obj_conv.inner = untag_ptr(this_obj);
42302 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42304 ShutdownScript_free(this_obj_conv);
42307 static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
42308 LDKShutdownScript ret_var = ShutdownScript_clone(arg);
42309 uint64_t ret_ref = 0;
42310 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42311 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42314 int64_t __attribute__((export_name("TS_ShutdownScript_clone_ptr"))) TS_ShutdownScript_clone_ptr(uint64_t arg) {
42315 LDKShutdownScript arg_conv;
42316 arg_conv.inner = untag_ptr(arg);
42317 arg_conv.is_owned = ptr_is_owned(arg);
42318 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42319 arg_conv.is_owned = false;
42320 int64_t ret_conv = ShutdownScript_clone_ptr(&arg_conv);
42324 uint64_t __attribute__((export_name("TS_ShutdownScript_clone"))) TS_ShutdownScript_clone(uint64_t orig) {
42325 LDKShutdownScript orig_conv;
42326 orig_conv.inner = untag_ptr(orig);
42327 orig_conv.is_owned = ptr_is_owned(orig);
42328 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42329 orig_conv.is_owned = false;
42330 LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
42331 uint64_t ret_ref = 0;
42332 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42333 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42337 jboolean __attribute__((export_name("TS_ShutdownScript_eq"))) TS_ShutdownScript_eq(uint64_t a, uint64_t b) {
42338 LDKShutdownScript a_conv;
42339 a_conv.inner = untag_ptr(a);
42340 a_conv.is_owned = ptr_is_owned(a);
42341 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42342 a_conv.is_owned = false;
42343 LDKShutdownScript b_conv;
42344 b_conv.inner = untag_ptr(b);
42345 b_conv.is_owned = ptr_is_owned(b);
42346 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42347 b_conv.is_owned = false;
42348 jboolean ret_conv = ShutdownScript_eq(&a_conv, &b_conv);
42352 void __attribute__((export_name("TS_InvalidShutdownScript_free"))) TS_InvalidShutdownScript_free(uint64_t this_obj) {
42353 LDKInvalidShutdownScript this_obj_conv;
42354 this_obj_conv.inner = untag_ptr(this_obj);
42355 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42356 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42357 InvalidShutdownScript_free(this_obj_conv);
42360 int8_tArray __attribute__((export_name("TS_InvalidShutdownScript_get_script"))) TS_InvalidShutdownScript_get_script(uint64_t this_ptr) {
42361 LDKInvalidShutdownScript this_ptr_conv;
42362 this_ptr_conv.inner = untag_ptr(this_ptr);
42363 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42365 this_ptr_conv.is_owned = false;
42366 LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
42367 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42368 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42372 void __attribute__((export_name("TS_InvalidShutdownScript_set_script"))) TS_InvalidShutdownScript_set_script(uint64_t this_ptr, int8_tArray val) {
42373 LDKInvalidShutdownScript this_ptr_conv;
42374 this_ptr_conv.inner = untag_ptr(this_ptr);
42375 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42377 this_ptr_conv.is_owned = false;
42378 LDKCVec_u8Z val_ref;
42379 val_ref.datalen = val->arr_len;
42380 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
42381 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
42382 InvalidShutdownScript_set_script(&this_ptr_conv, val_ref);
42385 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_new"))) TS_InvalidShutdownScript_new(int8_tArray script_arg) {
42386 LDKCVec_u8Z script_arg_ref;
42387 script_arg_ref.datalen = script_arg->arr_len;
42388 script_arg_ref.data = MALLOC(script_arg_ref.datalen, "LDKCVec_u8Z Bytes");
42389 memcpy(script_arg_ref.data, script_arg->elems, script_arg_ref.datalen); FREE(script_arg);
42390 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_new(script_arg_ref);
42391 uint64_t ret_ref = 0;
42392 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42393 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42397 static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
42398 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
42399 uint64_t ret_ref = 0;
42400 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42401 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42404 int64_t __attribute__((export_name("TS_InvalidShutdownScript_clone_ptr"))) TS_InvalidShutdownScript_clone_ptr(uint64_t arg) {
42405 LDKInvalidShutdownScript arg_conv;
42406 arg_conv.inner = untag_ptr(arg);
42407 arg_conv.is_owned = ptr_is_owned(arg);
42408 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42409 arg_conv.is_owned = false;
42410 int64_t ret_conv = InvalidShutdownScript_clone_ptr(&arg_conv);
42414 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_clone"))) TS_InvalidShutdownScript_clone(uint64_t orig) {
42415 LDKInvalidShutdownScript orig_conv;
42416 orig_conv.inner = untag_ptr(orig);
42417 orig_conv.is_owned = ptr_is_owned(orig);
42418 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42419 orig_conv.is_owned = false;
42420 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
42421 uint64_t ret_ref = 0;
42422 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42423 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42427 int8_tArray __attribute__((export_name("TS_ShutdownScript_write"))) TS_ShutdownScript_write(uint64_t obj) {
42428 LDKShutdownScript obj_conv;
42429 obj_conv.inner = untag_ptr(obj);
42430 obj_conv.is_owned = ptr_is_owned(obj);
42431 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42432 obj_conv.is_owned = false;
42433 LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
42434 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42435 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42436 CVec_u8Z_free(ret_var);
42440 uint64_t __attribute__((export_name("TS_ShutdownScript_read"))) TS_ShutdownScript_read(int8_tArray ser) {
42441 LDKu8slice ser_ref;
42442 ser_ref.datalen = ser->arr_len;
42443 ser_ref.data = ser->elems;
42444 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
42445 *ret_conv = ShutdownScript_read(ser_ref);
42447 return tag_ptr(ret_conv, true);
42450 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wpkh"))) TS_ShutdownScript_new_p2wpkh(int8_tArray pubkey_hash) {
42451 uint8_t pubkey_hash_arr[20];
42452 CHECK(pubkey_hash->arr_len == 20);
42453 memcpy(pubkey_hash_arr, pubkey_hash->elems, 20); FREE(pubkey_hash);
42454 uint8_t (*pubkey_hash_ref)[20] = &pubkey_hash_arr;
42455 LDKShutdownScript ret_var = ShutdownScript_new_p2wpkh(pubkey_hash_ref);
42456 uint64_t ret_ref = 0;
42457 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42458 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42462 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wsh"))) TS_ShutdownScript_new_p2wsh(int8_tArray script_hash) {
42463 uint8_t script_hash_arr[32];
42464 CHECK(script_hash->arr_len == 32);
42465 memcpy(script_hash_arr, script_hash->elems, 32); FREE(script_hash);
42466 uint8_t (*script_hash_ref)[32] = &script_hash_arr;
42467 LDKShutdownScript ret_var = ShutdownScript_new_p2wsh(script_hash_ref);
42468 uint64_t ret_ref = 0;
42469 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42470 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42474 uint64_t __attribute__((export_name("TS_ShutdownScript_new_witness_program"))) TS_ShutdownScript_new_witness_program(int8_t version, int8_tArray program) {
42476 LDKu8slice program_ref;
42477 program_ref.datalen = program->arr_len;
42478 program_ref.data = program->elems;
42479 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
42480 *ret_conv = ShutdownScript_new_witness_program((LDKWitnessVersion){ ._0 = version }, program_ref);
42482 return tag_ptr(ret_conv, true);
42485 int8_tArray __attribute__((export_name("TS_ShutdownScript_into_inner"))) TS_ShutdownScript_into_inner(uint64_t this_arg) {
42486 LDKShutdownScript this_arg_conv;
42487 this_arg_conv.inner = untag_ptr(this_arg);
42488 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42490 this_arg_conv = ShutdownScript_clone(&this_arg_conv);
42491 LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
42492 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42493 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42494 CVec_u8Z_free(ret_var);
42498 int8_tArray __attribute__((export_name("TS_ShutdownScript_as_legacy_pubkey"))) TS_ShutdownScript_as_legacy_pubkey(uint64_t this_arg) {
42499 LDKShutdownScript this_arg_conv;
42500 this_arg_conv.inner = untag_ptr(this_arg);
42501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42503 this_arg_conv.is_owned = false;
42504 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
42505 memcpy(ret_arr->elems, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
42509 jboolean __attribute__((export_name("TS_ShutdownScript_is_compatible"))) TS_ShutdownScript_is_compatible(uint64_t this_arg, uint64_t features) {
42510 LDKShutdownScript this_arg_conv;
42511 this_arg_conv.inner = untag_ptr(this_arg);
42512 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42514 this_arg_conv.is_owned = false;
42515 LDKInitFeatures features_conv;
42516 features_conv.inner = untag_ptr(features);
42517 features_conv.is_owned = ptr_is_owned(features);
42518 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
42519 features_conv.is_owned = false;
42520 jboolean ret_conv = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
42524 void __attribute__((export_name("TS_Retry_free"))) TS_Retry_free(uint64_t this_ptr) {
42525 if (!ptr_is_owned(this_ptr)) return;
42526 void* this_ptr_ptr = untag_ptr(this_ptr);
42527 CHECK_ACCESS(this_ptr_ptr);
42528 LDKRetry this_ptr_conv = *(LDKRetry*)(this_ptr_ptr);
42529 FREE(untag_ptr(this_ptr));
42530 Retry_free(this_ptr_conv);
42533 static inline uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg) {
42534 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
42535 *ret_copy = Retry_clone(arg);
42536 uint64_t ret_ref = tag_ptr(ret_copy, true);
42539 int64_t __attribute__((export_name("TS_Retry_clone_ptr"))) TS_Retry_clone_ptr(uint64_t arg) {
42540 LDKRetry* arg_conv = (LDKRetry*)untag_ptr(arg);
42541 int64_t ret_conv = Retry_clone_ptr(arg_conv);
42545 uint64_t __attribute__((export_name("TS_Retry_clone"))) TS_Retry_clone(uint64_t orig) {
42546 LDKRetry* orig_conv = (LDKRetry*)untag_ptr(orig);
42547 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
42548 *ret_copy = Retry_clone(orig_conv);
42549 uint64_t ret_ref = tag_ptr(ret_copy, true);
42553 uint64_t __attribute__((export_name("TS_Retry_attempts"))) TS_Retry_attempts(uint32_t a) {
42554 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
42555 *ret_copy = Retry_attempts(a);
42556 uint64_t ret_ref = tag_ptr(ret_copy, true);
42560 jboolean __attribute__((export_name("TS_Retry_eq"))) TS_Retry_eq(uint64_t a, uint64_t b) {
42561 LDKRetry* a_conv = (LDKRetry*)untag_ptr(a);
42562 LDKRetry* b_conv = (LDKRetry*)untag_ptr(b);
42563 jboolean ret_conv = Retry_eq(a_conv, b_conv);
42567 int64_t __attribute__((export_name("TS_Retry_hash"))) TS_Retry_hash(uint64_t o) {
42568 LDKRetry* o_conv = (LDKRetry*)untag_ptr(o);
42569 int64_t ret_conv = Retry_hash(o_conv);
42573 uint32_t __attribute__((export_name("TS_RetryableSendFailure_clone"))) TS_RetryableSendFailure_clone(uint64_t orig) {
42574 LDKRetryableSendFailure* orig_conv = (LDKRetryableSendFailure*)untag_ptr(orig);
42575 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_clone(orig_conv));
42579 uint32_t __attribute__((export_name("TS_RetryableSendFailure_payment_expired"))) TS_RetryableSendFailure_payment_expired() {
42580 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_payment_expired());
42584 uint32_t __attribute__((export_name("TS_RetryableSendFailure_route_not_found"))) TS_RetryableSendFailure_route_not_found() {
42585 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_route_not_found());
42589 uint32_t __attribute__((export_name("TS_RetryableSendFailure_duplicate_payment"))) TS_RetryableSendFailure_duplicate_payment() {
42590 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_duplicate_payment());
42594 void __attribute__((export_name("TS_PaymentSendFailure_free"))) TS_PaymentSendFailure_free(uint64_t this_ptr) {
42595 if (!ptr_is_owned(this_ptr)) return;
42596 void* this_ptr_ptr = untag_ptr(this_ptr);
42597 CHECK_ACCESS(this_ptr_ptr);
42598 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(this_ptr_ptr);
42599 FREE(untag_ptr(this_ptr));
42600 PaymentSendFailure_free(this_ptr_conv);
42603 static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
42604 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42605 *ret_copy = PaymentSendFailure_clone(arg);
42606 uint64_t ret_ref = tag_ptr(ret_copy, true);
42609 int64_t __attribute__((export_name("TS_PaymentSendFailure_clone_ptr"))) TS_PaymentSendFailure_clone_ptr(uint64_t arg) {
42610 LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)untag_ptr(arg);
42611 int64_t ret_conv = PaymentSendFailure_clone_ptr(arg_conv);
42615 uint64_t __attribute__((export_name("TS_PaymentSendFailure_clone"))) TS_PaymentSendFailure_clone(uint64_t orig) {
42616 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)untag_ptr(orig);
42617 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42618 *ret_copy = PaymentSendFailure_clone(orig_conv);
42619 uint64_t ret_ref = tag_ptr(ret_copy, true);
42623 uint64_t __attribute__((export_name("TS_PaymentSendFailure_parameter_error"))) TS_PaymentSendFailure_parameter_error(uint64_t a) {
42624 void* a_ptr = untag_ptr(a);
42625 CHECK_ACCESS(a_ptr);
42626 LDKAPIError a_conv = *(LDKAPIError*)(a_ptr);
42627 a_conv = APIError_clone((LDKAPIError*)untag_ptr(a));
42628 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42629 *ret_copy = PaymentSendFailure_parameter_error(a_conv);
42630 uint64_t ret_ref = tag_ptr(ret_copy, true);
42634 uint64_t __attribute__((export_name("TS_PaymentSendFailure_path_parameter_error"))) TS_PaymentSendFailure_path_parameter_error(uint64_tArray a) {
42635 LDKCVec_CResult_NoneAPIErrorZZ a_constr;
42636 a_constr.datalen = a->arr_len;
42637 if (a_constr.datalen > 0)
42638 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
42640 a_constr.data = NULL;
42641 uint64_t* a_vals = a->elems;
42642 for (size_t w = 0; w < a_constr.datalen; w++) {
42643 uint64_t a_conv_22 = a_vals[w];
42644 void* a_conv_22_ptr = untag_ptr(a_conv_22);
42645 CHECK_ACCESS(a_conv_22_ptr);
42646 LDKCResult_NoneAPIErrorZ a_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(a_conv_22_ptr);
42647 a_conv_22_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)untag_ptr(a_conv_22));
42648 a_constr.data[w] = a_conv_22_conv;
42651 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42652 *ret_copy = PaymentSendFailure_path_parameter_error(a_constr);
42653 uint64_t ret_ref = tag_ptr(ret_copy, true);
42657 uint64_t __attribute__((export_name("TS_PaymentSendFailure_all_failed_resend_safe"))) TS_PaymentSendFailure_all_failed_resend_safe(uint64_tArray a) {
42658 LDKCVec_APIErrorZ a_constr;
42659 a_constr.datalen = a->arr_len;
42660 if (a_constr.datalen > 0)
42661 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
42663 a_constr.data = NULL;
42664 uint64_t* a_vals = a->elems;
42665 for (size_t k = 0; k < a_constr.datalen; k++) {
42666 uint64_t a_conv_10 = a_vals[k];
42667 void* a_conv_10_ptr = untag_ptr(a_conv_10);
42668 CHECK_ACCESS(a_conv_10_ptr);
42669 LDKAPIError a_conv_10_conv = *(LDKAPIError*)(a_conv_10_ptr);
42670 a_conv_10_conv = APIError_clone((LDKAPIError*)untag_ptr(a_conv_10));
42671 a_constr.data[k] = a_conv_10_conv;
42674 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42675 *ret_copy = PaymentSendFailure_all_failed_resend_safe(a_constr);
42676 uint64_t ret_ref = tag_ptr(ret_copy, true);
42680 uint64_t __attribute__((export_name("TS_PaymentSendFailure_duplicate_payment"))) TS_PaymentSendFailure_duplicate_payment() {
42681 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42682 *ret_copy = PaymentSendFailure_duplicate_payment();
42683 uint64_t ret_ref = tag_ptr(ret_copy, true);
42687 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) {
42688 LDKCVec_CResult_NoneAPIErrorZZ results_constr;
42689 results_constr.datalen = results->arr_len;
42690 if (results_constr.datalen > 0)
42691 results_constr.data = MALLOC(results_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
42693 results_constr.data = NULL;
42694 uint64_t* results_vals = results->elems;
42695 for (size_t w = 0; w < results_constr.datalen; w++) {
42696 uint64_t results_conv_22 = results_vals[w];
42697 void* results_conv_22_ptr = untag_ptr(results_conv_22);
42698 CHECK_ACCESS(results_conv_22_ptr);
42699 LDKCResult_NoneAPIErrorZ results_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(results_conv_22_ptr);
42700 results_constr.data[w] = results_conv_22_conv;
42703 LDKRouteParameters failed_paths_retry_conv;
42704 failed_paths_retry_conv.inner = untag_ptr(failed_paths_retry);
42705 failed_paths_retry_conv.is_owned = ptr_is_owned(failed_paths_retry);
42706 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
42707 failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
42708 LDKThirtyTwoBytes payment_id_ref;
42709 CHECK(payment_id->arr_len == 32);
42710 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
42711 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42712 *ret_copy = PaymentSendFailure_partial_failure(results_constr, failed_paths_retry_conv, payment_id_ref);
42713 uint64_t ret_ref = tag_ptr(ret_copy, true);
42717 void __attribute__((export_name("TS_RecipientOnionFields_free"))) TS_RecipientOnionFields_free(uint64_t this_obj) {
42718 LDKRecipientOnionFields this_obj_conv;
42719 this_obj_conv.inner = untag_ptr(this_obj);
42720 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42722 RecipientOnionFields_free(this_obj_conv);
42725 int8_tArray __attribute__((export_name("TS_RecipientOnionFields_get_payment_secret"))) TS_RecipientOnionFields_get_payment_secret(uint64_t this_ptr) {
42726 LDKRecipientOnionFields this_ptr_conv;
42727 this_ptr_conv.inner = untag_ptr(this_ptr);
42728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42730 this_ptr_conv.is_owned = false;
42731 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
42732 memcpy(ret_arr->elems, RecipientOnionFields_get_payment_secret(&this_ptr_conv).data, 32);
42736 void __attribute__((export_name("TS_RecipientOnionFields_set_payment_secret"))) TS_RecipientOnionFields_set_payment_secret(uint64_t this_ptr, int8_tArray val) {
42737 LDKRecipientOnionFields this_ptr_conv;
42738 this_ptr_conv.inner = untag_ptr(this_ptr);
42739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42741 this_ptr_conv.is_owned = false;
42742 LDKThirtyTwoBytes val_ref;
42743 CHECK(val->arr_len == 32);
42744 memcpy(val_ref.data, val->elems, 32); FREE(val);
42745 RecipientOnionFields_set_payment_secret(&this_ptr_conv, val_ref);
42748 uint64_t __attribute__((export_name("TS_RecipientOnionFields_get_payment_metadata"))) TS_RecipientOnionFields_get_payment_metadata(uint64_t this_ptr) {
42749 LDKRecipientOnionFields this_ptr_conv;
42750 this_ptr_conv.inner = untag_ptr(this_ptr);
42751 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42753 this_ptr_conv.is_owned = false;
42754 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
42755 *ret_copy = RecipientOnionFields_get_payment_metadata(&this_ptr_conv);
42756 uint64_t ret_ref = tag_ptr(ret_copy, true);
42760 void __attribute__((export_name("TS_RecipientOnionFields_set_payment_metadata"))) TS_RecipientOnionFields_set_payment_metadata(uint64_t this_ptr, uint64_t val) {
42761 LDKRecipientOnionFields this_ptr_conv;
42762 this_ptr_conv.inner = untag_ptr(this_ptr);
42763 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42764 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42765 this_ptr_conv.is_owned = false;
42766 void* val_ptr = untag_ptr(val);
42767 CHECK_ACCESS(val_ptr);
42768 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
42769 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
42770 RecipientOnionFields_set_payment_metadata(&this_ptr_conv, val_conv);
42773 uint64_t __attribute__((export_name("TS_RecipientOnionFields_new"))) TS_RecipientOnionFields_new(int8_tArray payment_secret_arg, uint64_t payment_metadata_arg) {
42774 LDKThirtyTwoBytes payment_secret_arg_ref;
42775 CHECK(payment_secret_arg->arr_len == 32);
42776 memcpy(payment_secret_arg_ref.data, payment_secret_arg->elems, 32); FREE(payment_secret_arg);
42777 void* payment_metadata_arg_ptr = untag_ptr(payment_metadata_arg);
42778 CHECK_ACCESS(payment_metadata_arg_ptr);
42779 LDKCOption_CVec_u8ZZ payment_metadata_arg_conv = *(LDKCOption_CVec_u8ZZ*)(payment_metadata_arg_ptr);
42780 payment_metadata_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(payment_metadata_arg));
42781 LDKRecipientOnionFields ret_var = RecipientOnionFields_new(payment_secret_arg_ref, payment_metadata_arg_conv);
42782 uint64_t ret_ref = 0;
42783 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42784 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42788 static inline uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg) {
42789 LDKRecipientOnionFields ret_var = RecipientOnionFields_clone(arg);
42790 uint64_t ret_ref = 0;
42791 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42792 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42795 int64_t __attribute__((export_name("TS_RecipientOnionFields_clone_ptr"))) TS_RecipientOnionFields_clone_ptr(uint64_t arg) {
42796 LDKRecipientOnionFields arg_conv;
42797 arg_conv.inner = untag_ptr(arg);
42798 arg_conv.is_owned = ptr_is_owned(arg);
42799 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42800 arg_conv.is_owned = false;
42801 int64_t ret_conv = RecipientOnionFields_clone_ptr(&arg_conv);
42805 uint64_t __attribute__((export_name("TS_RecipientOnionFields_clone"))) TS_RecipientOnionFields_clone(uint64_t orig) {
42806 LDKRecipientOnionFields orig_conv;
42807 orig_conv.inner = untag_ptr(orig);
42808 orig_conv.is_owned = ptr_is_owned(orig);
42809 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42810 orig_conv.is_owned = false;
42811 LDKRecipientOnionFields ret_var = RecipientOnionFields_clone(&orig_conv);
42812 uint64_t ret_ref = 0;
42813 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42814 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42818 jboolean __attribute__((export_name("TS_RecipientOnionFields_eq"))) TS_RecipientOnionFields_eq(uint64_t a, uint64_t b) {
42819 LDKRecipientOnionFields a_conv;
42820 a_conv.inner = untag_ptr(a);
42821 a_conv.is_owned = ptr_is_owned(a);
42822 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42823 a_conv.is_owned = false;
42824 LDKRecipientOnionFields b_conv;
42825 b_conv.inner = untag_ptr(b);
42826 b_conv.is_owned = ptr_is_owned(b);
42827 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42828 b_conv.is_owned = false;
42829 jboolean ret_conv = RecipientOnionFields_eq(&a_conv, &b_conv);
42833 int8_tArray __attribute__((export_name("TS_RecipientOnionFields_write"))) TS_RecipientOnionFields_write(uint64_t obj) {
42834 LDKRecipientOnionFields obj_conv;
42835 obj_conv.inner = untag_ptr(obj);
42836 obj_conv.is_owned = ptr_is_owned(obj);
42837 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42838 obj_conv.is_owned = false;
42839 LDKCVec_u8Z ret_var = RecipientOnionFields_write(&obj_conv);
42840 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42841 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42842 CVec_u8Z_free(ret_var);
42846 uint64_t __attribute__((export_name("TS_RecipientOnionFields_read"))) TS_RecipientOnionFields_read(int8_tArray ser) {
42847 LDKu8slice ser_ref;
42848 ser_ref.datalen = ser->arr_len;
42849 ser_ref.data = ser->elems;
42850 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
42851 *ret_conv = RecipientOnionFields_read(ser_ref);
42853 return tag_ptr(ret_conv, true);
42856 uint64_t __attribute__((export_name("TS_RecipientOnionFields_secret_only"))) TS_RecipientOnionFields_secret_only(int8_tArray payment_secret) {
42857 LDKThirtyTwoBytes payment_secret_ref;
42858 CHECK(payment_secret->arr_len == 32);
42859 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
42860 LDKRecipientOnionFields ret_var = RecipientOnionFields_secret_only(payment_secret_ref);
42861 uint64_t ret_ref = 0;
42862 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42863 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42867 uint64_t __attribute__((export_name("TS_RecipientOnionFields_spontaneous_empty"))) TS_RecipientOnionFields_spontaneous_empty() {
42868 LDKRecipientOnionFields ret_var = RecipientOnionFields_spontaneous_empty();
42869 uint64_t ret_ref = 0;
42870 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42871 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42875 void __attribute__((export_name("TS_CustomMessageReader_free"))) TS_CustomMessageReader_free(uint64_t this_ptr) {
42876 if (!ptr_is_owned(this_ptr)) return;
42877 void* this_ptr_ptr = untag_ptr(this_ptr);
42878 CHECK_ACCESS(this_ptr_ptr);
42879 LDKCustomMessageReader this_ptr_conv = *(LDKCustomMessageReader*)(this_ptr_ptr);
42880 FREE(untag_ptr(this_ptr));
42881 CustomMessageReader_free(this_ptr_conv);
42884 static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
42885 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
42886 *ret_ret = Type_clone(arg);
42887 return tag_ptr(ret_ret, true);
42889 int64_t __attribute__((export_name("TS_Type_clone_ptr"))) TS_Type_clone_ptr(uint64_t arg) {
42890 void* arg_ptr = untag_ptr(arg);
42891 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
42892 LDKType* arg_conv = (LDKType*)arg_ptr;
42893 int64_t ret_conv = Type_clone_ptr(arg_conv);
42897 uint64_t __attribute__((export_name("TS_Type_clone"))) TS_Type_clone(uint64_t orig) {
42898 void* orig_ptr = untag_ptr(orig);
42899 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
42900 LDKType* orig_conv = (LDKType*)orig_ptr;
42901 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
42902 *ret_ret = Type_clone(orig_conv);
42903 return tag_ptr(ret_ret, true);
42906 void __attribute__((export_name("TS_Type_free"))) TS_Type_free(uint64_t this_ptr) {
42907 if (!ptr_is_owned(this_ptr)) return;
42908 void* this_ptr_ptr = untag_ptr(this_ptr);
42909 CHECK_ACCESS(this_ptr_ptr);
42910 LDKType this_ptr_conv = *(LDKType*)(this_ptr_ptr);
42911 FREE(untag_ptr(this_ptr));
42912 Type_free(this_ptr_conv);
42915 void __attribute__((export_name("TS_UnsignedInvoice_free"))) TS_UnsignedInvoice_free(uint64_t this_obj) {
42916 LDKUnsignedInvoice this_obj_conv;
42917 this_obj_conv.inner = untag_ptr(this_obj);
42918 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42920 UnsignedInvoice_free(this_obj_conv);
42923 int8_tArray __attribute__((export_name("TS_UnsignedInvoice_signing_pubkey"))) TS_UnsignedInvoice_signing_pubkey(uint64_t this_arg) {
42924 LDKUnsignedInvoice this_arg_conv;
42925 this_arg_conv.inner = untag_ptr(this_arg);
42926 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42928 this_arg_conv.is_owned = false;
42929 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
42930 memcpy(ret_arr->elems, UnsignedInvoice_signing_pubkey(&this_arg_conv).compressed_form, 33);
42934 void __attribute__((export_name("TS_BlindedPayInfo_free"))) TS_BlindedPayInfo_free(uint64_t this_obj) {
42935 LDKBlindedPayInfo this_obj_conv;
42936 this_obj_conv.inner = untag_ptr(this_obj);
42937 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42938 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42939 BlindedPayInfo_free(this_obj_conv);
42942 int32_t __attribute__((export_name("TS_BlindedPayInfo_get_fee_base_msat"))) TS_BlindedPayInfo_get_fee_base_msat(uint64_t this_ptr) {
42943 LDKBlindedPayInfo this_ptr_conv;
42944 this_ptr_conv.inner = untag_ptr(this_ptr);
42945 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42947 this_ptr_conv.is_owned = false;
42948 int32_t ret_conv = BlindedPayInfo_get_fee_base_msat(&this_ptr_conv);
42952 void __attribute__((export_name("TS_BlindedPayInfo_set_fee_base_msat"))) TS_BlindedPayInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
42953 LDKBlindedPayInfo this_ptr_conv;
42954 this_ptr_conv.inner = untag_ptr(this_ptr);
42955 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42957 this_ptr_conv.is_owned = false;
42958 BlindedPayInfo_set_fee_base_msat(&this_ptr_conv, val);
42961 int32_t __attribute__((export_name("TS_BlindedPayInfo_get_fee_proportional_millionths"))) TS_BlindedPayInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
42962 LDKBlindedPayInfo this_ptr_conv;
42963 this_ptr_conv.inner = untag_ptr(this_ptr);
42964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42966 this_ptr_conv.is_owned = false;
42967 int32_t ret_conv = BlindedPayInfo_get_fee_proportional_millionths(&this_ptr_conv);
42971 void __attribute__((export_name("TS_BlindedPayInfo_set_fee_proportional_millionths"))) TS_BlindedPayInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
42972 LDKBlindedPayInfo this_ptr_conv;
42973 this_ptr_conv.inner = untag_ptr(this_ptr);
42974 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42975 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42976 this_ptr_conv.is_owned = false;
42977 BlindedPayInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
42980 int16_t __attribute__((export_name("TS_BlindedPayInfo_get_cltv_expiry_delta"))) TS_BlindedPayInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
42981 LDKBlindedPayInfo this_ptr_conv;
42982 this_ptr_conv.inner = untag_ptr(this_ptr);
42983 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42985 this_ptr_conv.is_owned = false;
42986 int16_t ret_conv = BlindedPayInfo_get_cltv_expiry_delta(&this_ptr_conv);
42990 void __attribute__((export_name("TS_BlindedPayInfo_set_cltv_expiry_delta"))) TS_BlindedPayInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
42991 LDKBlindedPayInfo this_ptr_conv;
42992 this_ptr_conv.inner = untag_ptr(this_ptr);
42993 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42995 this_ptr_conv.is_owned = false;
42996 BlindedPayInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
42999 int64_t __attribute__((export_name("TS_BlindedPayInfo_get_htlc_minimum_msat"))) TS_BlindedPayInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
43000 LDKBlindedPayInfo this_ptr_conv;
43001 this_ptr_conv.inner = untag_ptr(this_ptr);
43002 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43004 this_ptr_conv.is_owned = false;
43005 int64_t ret_conv = BlindedPayInfo_get_htlc_minimum_msat(&this_ptr_conv);
43009 void __attribute__((export_name("TS_BlindedPayInfo_set_htlc_minimum_msat"))) TS_BlindedPayInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
43010 LDKBlindedPayInfo this_ptr_conv;
43011 this_ptr_conv.inner = untag_ptr(this_ptr);
43012 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43014 this_ptr_conv.is_owned = false;
43015 BlindedPayInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
43018 int64_t __attribute__((export_name("TS_BlindedPayInfo_get_htlc_maximum_msat"))) TS_BlindedPayInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
43019 LDKBlindedPayInfo this_ptr_conv;
43020 this_ptr_conv.inner = untag_ptr(this_ptr);
43021 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43023 this_ptr_conv.is_owned = false;
43024 int64_t ret_conv = BlindedPayInfo_get_htlc_maximum_msat(&this_ptr_conv);
43028 void __attribute__((export_name("TS_BlindedPayInfo_set_htlc_maximum_msat"))) TS_BlindedPayInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
43029 LDKBlindedPayInfo this_ptr_conv;
43030 this_ptr_conv.inner = untag_ptr(this_ptr);
43031 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43032 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43033 this_ptr_conv.is_owned = false;
43034 BlindedPayInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
43037 uint64_t __attribute__((export_name("TS_BlindedPayInfo_get_features"))) TS_BlindedPayInfo_get_features(uint64_t this_ptr) {
43038 LDKBlindedPayInfo this_ptr_conv;
43039 this_ptr_conv.inner = untag_ptr(this_ptr);
43040 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43042 this_ptr_conv.is_owned = false;
43043 LDKBlindedHopFeatures ret_var = BlindedPayInfo_get_features(&this_ptr_conv);
43044 uint64_t ret_ref = 0;
43045 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43046 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43050 void __attribute__((export_name("TS_BlindedPayInfo_set_features"))) TS_BlindedPayInfo_set_features(uint64_t this_ptr, uint64_t val) {
43051 LDKBlindedPayInfo this_ptr_conv;
43052 this_ptr_conv.inner = untag_ptr(this_ptr);
43053 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43054 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43055 this_ptr_conv.is_owned = false;
43056 LDKBlindedHopFeatures val_conv;
43057 val_conv.inner = untag_ptr(val);
43058 val_conv.is_owned = ptr_is_owned(val);
43059 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43060 val_conv = BlindedHopFeatures_clone(&val_conv);
43061 BlindedPayInfo_set_features(&this_ptr_conv, val_conv);
43064 uint64_t __attribute__((export_name("TS_BlindedPayInfo_new"))) TS_BlindedPayInfo_new(int32_t fee_base_msat_arg, int32_t fee_proportional_millionths_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, int64_t htlc_maximum_msat_arg, uint64_t features_arg) {
43065 LDKBlindedHopFeatures features_arg_conv;
43066 features_arg_conv.inner = untag_ptr(features_arg);
43067 features_arg_conv.is_owned = ptr_is_owned(features_arg);
43068 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
43069 features_arg_conv = BlindedHopFeatures_clone(&features_arg_conv);
43070 LDKBlindedPayInfo ret_var = BlindedPayInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, features_arg_conv);
43071 uint64_t ret_ref = 0;
43072 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43073 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43077 static inline uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg) {
43078 LDKBlindedPayInfo ret_var = BlindedPayInfo_clone(arg);
43079 uint64_t ret_ref = 0;
43080 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43081 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43084 int64_t __attribute__((export_name("TS_BlindedPayInfo_clone_ptr"))) TS_BlindedPayInfo_clone_ptr(uint64_t arg) {
43085 LDKBlindedPayInfo arg_conv;
43086 arg_conv.inner = untag_ptr(arg);
43087 arg_conv.is_owned = ptr_is_owned(arg);
43088 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43089 arg_conv.is_owned = false;
43090 int64_t ret_conv = BlindedPayInfo_clone_ptr(&arg_conv);
43094 uint64_t __attribute__((export_name("TS_BlindedPayInfo_clone"))) TS_BlindedPayInfo_clone(uint64_t orig) {
43095 LDKBlindedPayInfo orig_conv;
43096 orig_conv.inner = untag_ptr(orig);
43097 orig_conv.is_owned = ptr_is_owned(orig);
43098 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43099 orig_conv.is_owned = false;
43100 LDKBlindedPayInfo ret_var = BlindedPayInfo_clone(&orig_conv);
43101 uint64_t ret_ref = 0;
43102 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43103 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43107 int64_t __attribute__((export_name("TS_BlindedPayInfo_hash"))) TS_BlindedPayInfo_hash(uint64_t o) {
43108 LDKBlindedPayInfo o_conv;
43109 o_conv.inner = untag_ptr(o);
43110 o_conv.is_owned = ptr_is_owned(o);
43111 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
43112 o_conv.is_owned = false;
43113 int64_t ret_conv = BlindedPayInfo_hash(&o_conv);
43117 jboolean __attribute__((export_name("TS_BlindedPayInfo_eq"))) TS_BlindedPayInfo_eq(uint64_t a, uint64_t b) {
43118 LDKBlindedPayInfo a_conv;
43119 a_conv.inner = untag_ptr(a);
43120 a_conv.is_owned = ptr_is_owned(a);
43121 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43122 a_conv.is_owned = false;
43123 LDKBlindedPayInfo b_conv;
43124 b_conv.inner = untag_ptr(b);
43125 b_conv.is_owned = ptr_is_owned(b);
43126 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43127 b_conv.is_owned = false;
43128 jboolean ret_conv = BlindedPayInfo_eq(&a_conv, &b_conv);
43132 int8_tArray __attribute__((export_name("TS_BlindedPayInfo_write"))) TS_BlindedPayInfo_write(uint64_t obj) {
43133 LDKBlindedPayInfo obj_conv;
43134 obj_conv.inner = untag_ptr(obj);
43135 obj_conv.is_owned = ptr_is_owned(obj);
43136 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43137 obj_conv.is_owned = false;
43138 LDKCVec_u8Z ret_var = BlindedPayInfo_write(&obj_conv);
43139 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43140 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43141 CVec_u8Z_free(ret_var);
43145 uint64_t __attribute__((export_name("TS_BlindedPayInfo_read"))) TS_BlindedPayInfo_read(int8_tArray ser) {
43146 LDKu8slice ser_ref;
43147 ser_ref.datalen = ser->arr_len;
43148 ser_ref.data = ser->elems;
43149 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
43150 *ret_conv = BlindedPayInfo_read(ser_ref);
43152 return tag_ptr(ret_conv, true);
43155 void __attribute__((export_name("TS_UnsignedInvoiceRequest_free"))) TS_UnsignedInvoiceRequest_free(uint64_t this_obj) {
43156 LDKUnsignedInvoiceRequest this_obj_conv;
43157 this_obj_conv.inner = untag_ptr(this_obj);
43158 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43160 UnsignedInvoiceRequest_free(this_obj_conv);
43163 void __attribute__((export_name("TS_InvoiceRequest_free"))) TS_InvoiceRequest_free(uint64_t this_obj) {
43164 LDKInvoiceRequest this_obj_conv;
43165 this_obj_conv.inner = untag_ptr(this_obj);
43166 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43168 InvoiceRequest_free(this_obj_conv);
43171 static inline uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg) {
43172 LDKInvoiceRequest ret_var = InvoiceRequest_clone(arg);
43173 uint64_t ret_ref = 0;
43174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43175 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43178 int64_t __attribute__((export_name("TS_InvoiceRequest_clone_ptr"))) TS_InvoiceRequest_clone_ptr(uint64_t arg) {
43179 LDKInvoiceRequest arg_conv;
43180 arg_conv.inner = untag_ptr(arg);
43181 arg_conv.is_owned = ptr_is_owned(arg);
43182 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43183 arg_conv.is_owned = false;
43184 int64_t ret_conv = InvoiceRequest_clone_ptr(&arg_conv);
43188 uint64_t __attribute__((export_name("TS_InvoiceRequest_clone"))) TS_InvoiceRequest_clone(uint64_t orig) {
43189 LDKInvoiceRequest orig_conv;
43190 orig_conv.inner = untag_ptr(orig);
43191 orig_conv.is_owned = ptr_is_owned(orig);
43192 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43193 orig_conv.is_owned = false;
43194 LDKInvoiceRequest ret_var = InvoiceRequest_clone(&orig_conv);
43195 uint64_t ret_ref = 0;
43196 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43197 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43201 int8_tArray __attribute__((export_name("TS_InvoiceRequest_metadata"))) TS_InvoiceRequest_metadata(uint64_t this_arg) {
43202 LDKInvoiceRequest this_arg_conv;
43203 this_arg_conv.inner = untag_ptr(this_arg);
43204 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43206 this_arg_conv.is_owned = false;
43207 LDKu8slice ret_var = InvoiceRequest_metadata(&this_arg_conv);
43208 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43209 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43213 int8_tArray __attribute__((export_name("TS_InvoiceRequest_chain"))) TS_InvoiceRequest_chain(uint64_t this_arg) {
43214 LDKInvoiceRequest this_arg_conv;
43215 this_arg_conv.inner = untag_ptr(this_arg);
43216 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43218 this_arg_conv.is_owned = false;
43219 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43220 memcpy(ret_arr->elems, InvoiceRequest_chain(&this_arg_conv).data, 32);
43224 uint64_t __attribute__((export_name("TS_InvoiceRequest_amount_msats"))) TS_InvoiceRequest_amount_msats(uint64_t this_arg) {
43225 LDKInvoiceRequest this_arg_conv;
43226 this_arg_conv.inner = untag_ptr(this_arg);
43227 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43228 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43229 this_arg_conv.is_owned = false;
43230 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43231 *ret_copy = InvoiceRequest_amount_msats(&this_arg_conv);
43232 uint64_t ret_ref = tag_ptr(ret_copy, true);
43236 uint64_t __attribute__((export_name("TS_InvoiceRequest_features"))) TS_InvoiceRequest_features(uint64_t this_arg) {
43237 LDKInvoiceRequest this_arg_conv;
43238 this_arg_conv.inner = untag_ptr(this_arg);
43239 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43241 this_arg_conv.is_owned = false;
43242 LDKInvoiceRequestFeatures ret_var = InvoiceRequest_features(&this_arg_conv);
43243 uint64_t ret_ref = 0;
43244 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43245 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43249 uint64_t __attribute__((export_name("TS_InvoiceRequest_quantity"))) TS_InvoiceRequest_quantity(uint64_t this_arg) {
43250 LDKInvoiceRequest this_arg_conv;
43251 this_arg_conv.inner = untag_ptr(this_arg);
43252 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43254 this_arg_conv.is_owned = false;
43255 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43256 *ret_copy = InvoiceRequest_quantity(&this_arg_conv);
43257 uint64_t ret_ref = tag_ptr(ret_copy, true);
43261 int8_tArray __attribute__((export_name("TS_InvoiceRequest_payer_id"))) TS_InvoiceRequest_payer_id(uint64_t this_arg) {
43262 LDKInvoiceRequest this_arg_conv;
43263 this_arg_conv.inner = untag_ptr(this_arg);
43264 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43266 this_arg_conv.is_owned = false;
43267 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43268 memcpy(ret_arr->elems, InvoiceRequest_payer_id(&this_arg_conv).compressed_form, 33);
43272 uint64_t __attribute__((export_name("TS_InvoiceRequest_payer_note"))) TS_InvoiceRequest_payer_note(uint64_t this_arg) {
43273 LDKInvoiceRequest this_arg_conv;
43274 this_arg_conv.inner = untag_ptr(this_arg);
43275 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43277 this_arg_conv.is_owned = false;
43278 LDKPrintableString ret_var = InvoiceRequest_payer_note(&this_arg_conv);
43279 uint64_t ret_ref = 0;
43280 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43281 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43285 int8_tArray __attribute__((export_name("TS_InvoiceRequest_write"))) TS_InvoiceRequest_write(uint64_t obj) {
43286 LDKInvoiceRequest obj_conv;
43287 obj_conv.inner = untag_ptr(obj);
43288 obj_conv.is_owned = ptr_is_owned(obj);
43289 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43290 obj_conv.is_owned = false;
43291 LDKCVec_u8Z ret_var = InvoiceRequest_write(&obj_conv);
43292 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43293 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43294 CVec_u8Z_free(ret_var);
43298 void __attribute__((export_name("TS_Offer_free"))) TS_Offer_free(uint64_t this_obj) {
43299 LDKOffer this_obj_conv;
43300 this_obj_conv.inner = untag_ptr(this_obj);
43301 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43303 Offer_free(this_obj_conv);
43306 static inline uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg) {
43307 LDKOffer ret_var = Offer_clone(arg);
43308 uint64_t ret_ref = 0;
43309 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43310 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43313 int64_t __attribute__((export_name("TS_Offer_clone_ptr"))) TS_Offer_clone_ptr(uint64_t arg) {
43315 arg_conv.inner = untag_ptr(arg);
43316 arg_conv.is_owned = ptr_is_owned(arg);
43317 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43318 arg_conv.is_owned = false;
43319 int64_t ret_conv = Offer_clone_ptr(&arg_conv);
43323 uint64_t __attribute__((export_name("TS_Offer_clone"))) TS_Offer_clone(uint64_t orig) {
43324 LDKOffer orig_conv;
43325 orig_conv.inner = untag_ptr(orig);
43326 orig_conv.is_owned = ptr_is_owned(orig);
43327 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43328 orig_conv.is_owned = false;
43329 LDKOffer ret_var = Offer_clone(&orig_conv);
43330 uint64_t ret_ref = 0;
43331 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43332 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43336 ptrArray __attribute__((export_name("TS_Offer_chains"))) TS_Offer_chains(uint64_t this_arg) {
43337 LDKOffer this_arg_conv;
43338 this_arg_conv.inner = untag_ptr(this_arg);
43339 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43341 this_arg_conv.is_owned = false;
43342 LDKCVec_ChainHashZ ret_var = Offer_chains(&this_arg_conv);
43343 ptrArray ret_arr = NULL;
43344 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
43345 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
43346 for (size_t m = 0; m < ret_var.datalen; m++) {
43347 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
43348 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
43349 ret_arr_ptr[m] = ret_conv_12_arr;
43352 FREE(ret_var.data);
43356 jboolean __attribute__((export_name("TS_Offer_supports_chain"))) TS_Offer_supports_chain(uint64_t this_arg, int8_tArray chain) {
43357 LDKOffer this_arg_conv;
43358 this_arg_conv.inner = untag_ptr(this_arg);
43359 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43361 this_arg_conv.is_owned = false;
43362 LDKThirtyTwoBytes chain_ref;
43363 CHECK(chain->arr_len == 32);
43364 memcpy(chain_ref.data, chain->elems, 32); FREE(chain);
43365 jboolean ret_conv = Offer_supports_chain(&this_arg_conv, chain_ref);
43369 uint64_t __attribute__((export_name("TS_Offer_metadata"))) TS_Offer_metadata(uint64_t this_arg) {
43370 LDKOffer this_arg_conv;
43371 this_arg_conv.inner = untag_ptr(this_arg);
43372 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43374 this_arg_conv.is_owned = false;
43375 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
43376 *ret_copy = Offer_metadata(&this_arg_conv);
43377 uint64_t ret_ref = tag_ptr(ret_copy, true);
43381 uint64_t __attribute__((export_name("TS_Offer_amount"))) TS_Offer_amount(uint64_t this_arg) {
43382 LDKOffer this_arg_conv;
43383 this_arg_conv.inner = untag_ptr(this_arg);
43384 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43386 this_arg_conv.is_owned = false;
43387 LDKAmount ret_var = Offer_amount(&this_arg_conv);
43388 uint64_t ret_ref = 0;
43389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43394 uint64_t __attribute__((export_name("TS_Offer_description"))) TS_Offer_description(uint64_t this_arg) {
43395 LDKOffer this_arg_conv;
43396 this_arg_conv.inner = untag_ptr(this_arg);
43397 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43399 this_arg_conv.is_owned = false;
43400 LDKPrintableString ret_var = Offer_description(&this_arg_conv);
43401 uint64_t ret_ref = 0;
43402 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43403 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43407 uint64_t __attribute__((export_name("TS_Offer_features"))) TS_Offer_features(uint64_t this_arg) {
43408 LDKOffer this_arg_conv;
43409 this_arg_conv.inner = untag_ptr(this_arg);
43410 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43412 this_arg_conv.is_owned = false;
43413 LDKOfferFeatures ret_var = Offer_features(&this_arg_conv);
43414 uint64_t ret_ref = 0;
43415 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43416 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43420 uint64_t __attribute__((export_name("TS_Offer_absolute_expiry"))) TS_Offer_absolute_expiry(uint64_t this_arg) {
43421 LDKOffer this_arg_conv;
43422 this_arg_conv.inner = untag_ptr(this_arg);
43423 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43424 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43425 this_arg_conv.is_owned = false;
43426 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
43427 *ret_copy = Offer_absolute_expiry(&this_arg_conv);
43428 uint64_t ret_ref = tag_ptr(ret_copy, true);
43432 uint64_t __attribute__((export_name("TS_Offer_issuer"))) TS_Offer_issuer(uint64_t this_arg) {
43433 LDKOffer this_arg_conv;
43434 this_arg_conv.inner = untag_ptr(this_arg);
43435 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43436 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43437 this_arg_conv.is_owned = false;
43438 LDKPrintableString ret_var = Offer_issuer(&this_arg_conv);
43439 uint64_t ret_ref = 0;
43440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43441 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43445 uint64_tArray __attribute__((export_name("TS_Offer_paths"))) TS_Offer_paths(uint64_t this_arg) {
43446 LDKOffer this_arg_conv;
43447 this_arg_conv.inner = untag_ptr(this_arg);
43448 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43450 this_arg_conv.is_owned = false;
43451 LDKCVec_BlindedPathZ ret_var = Offer_paths(&this_arg_conv);
43452 uint64_tArray ret_arr = NULL;
43453 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
43454 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
43455 for (size_t n = 0; n < ret_var.datalen; n++) {
43456 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
43457 uint64_t ret_conv_13_ref = 0;
43458 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
43459 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
43460 ret_arr_ptr[n] = ret_conv_13_ref;
43463 FREE(ret_var.data);
43467 uint64_t __attribute__((export_name("TS_Offer_supported_quantity"))) TS_Offer_supported_quantity(uint64_t this_arg) {
43468 LDKOffer this_arg_conv;
43469 this_arg_conv.inner = untag_ptr(this_arg);
43470 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43472 this_arg_conv.is_owned = false;
43473 LDKQuantity ret_var = Offer_supported_quantity(&this_arg_conv);
43474 uint64_t ret_ref = 0;
43475 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43476 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43480 jboolean __attribute__((export_name("TS_Offer_is_valid_quantity"))) TS_Offer_is_valid_quantity(uint64_t this_arg, int64_t quantity) {
43481 LDKOffer this_arg_conv;
43482 this_arg_conv.inner = untag_ptr(this_arg);
43483 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43485 this_arg_conv.is_owned = false;
43486 jboolean ret_conv = Offer_is_valid_quantity(&this_arg_conv, quantity);
43490 jboolean __attribute__((export_name("TS_Offer_expects_quantity"))) TS_Offer_expects_quantity(uint64_t this_arg) {
43491 LDKOffer this_arg_conv;
43492 this_arg_conv.inner = untag_ptr(this_arg);
43493 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43495 this_arg_conv.is_owned = false;
43496 jboolean ret_conv = Offer_expects_quantity(&this_arg_conv);
43500 int8_tArray __attribute__((export_name("TS_Offer_signing_pubkey"))) TS_Offer_signing_pubkey(uint64_t this_arg) {
43501 LDKOffer this_arg_conv;
43502 this_arg_conv.inner = untag_ptr(this_arg);
43503 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43504 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43505 this_arg_conv.is_owned = false;
43506 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43507 memcpy(ret_arr->elems, Offer_signing_pubkey(&this_arg_conv).compressed_form, 33);
43511 int8_tArray __attribute__((export_name("TS_Offer_write"))) TS_Offer_write(uint64_t obj) {
43513 obj_conv.inner = untag_ptr(obj);
43514 obj_conv.is_owned = ptr_is_owned(obj);
43515 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43516 obj_conv.is_owned = false;
43517 LDKCVec_u8Z ret_var = Offer_write(&obj_conv);
43518 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43519 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43520 CVec_u8Z_free(ret_var);
43524 void __attribute__((export_name("TS_Amount_free"))) TS_Amount_free(uint64_t this_obj) {
43525 LDKAmount this_obj_conv;
43526 this_obj_conv.inner = untag_ptr(this_obj);
43527 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43528 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43529 Amount_free(this_obj_conv);
43532 static inline uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg) {
43533 LDKAmount ret_var = Amount_clone(arg);
43534 uint64_t ret_ref = 0;
43535 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43536 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43539 int64_t __attribute__((export_name("TS_Amount_clone_ptr"))) TS_Amount_clone_ptr(uint64_t arg) {
43540 LDKAmount arg_conv;
43541 arg_conv.inner = untag_ptr(arg);
43542 arg_conv.is_owned = ptr_is_owned(arg);
43543 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43544 arg_conv.is_owned = false;
43545 int64_t ret_conv = Amount_clone_ptr(&arg_conv);
43549 uint64_t __attribute__((export_name("TS_Amount_clone"))) TS_Amount_clone(uint64_t orig) {
43550 LDKAmount orig_conv;
43551 orig_conv.inner = untag_ptr(orig);
43552 orig_conv.is_owned = ptr_is_owned(orig);
43553 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43554 orig_conv.is_owned = false;
43555 LDKAmount ret_var = Amount_clone(&orig_conv);
43556 uint64_t ret_ref = 0;
43557 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43558 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43562 void __attribute__((export_name("TS_Quantity_free"))) TS_Quantity_free(uint64_t this_obj) {
43563 LDKQuantity this_obj_conv;
43564 this_obj_conv.inner = untag_ptr(this_obj);
43565 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43567 Quantity_free(this_obj_conv);
43570 static inline uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg) {
43571 LDKQuantity ret_var = Quantity_clone(arg);
43572 uint64_t ret_ref = 0;
43573 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43574 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43577 int64_t __attribute__((export_name("TS_Quantity_clone_ptr"))) TS_Quantity_clone_ptr(uint64_t arg) {
43578 LDKQuantity arg_conv;
43579 arg_conv.inner = untag_ptr(arg);
43580 arg_conv.is_owned = ptr_is_owned(arg);
43581 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43582 arg_conv.is_owned = false;
43583 int64_t ret_conv = Quantity_clone_ptr(&arg_conv);
43587 uint64_t __attribute__((export_name("TS_Quantity_clone"))) TS_Quantity_clone(uint64_t orig) {
43588 LDKQuantity orig_conv;
43589 orig_conv.inner = untag_ptr(orig);
43590 orig_conv.is_owned = ptr_is_owned(orig);
43591 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43592 orig_conv.is_owned = false;
43593 LDKQuantity ret_var = Quantity_clone(&orig_conv);
43594 uint64_t ret_ref = 0;
43595 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43596 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43600 void __attribute__((export_name("TS_Refund_free"))) TS_Refund_free(uint64_t this_obj) {
43601 LDKRefund this_obj_conv;
43602 this_obj_conv.inner = untag_ptr(this_obj);
43603 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43605 Refund_free(this_obj_conv);
43608 static inline uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg) {
43609 LDKRefund ret_var = Refund_clone(arg);
43610 uint64_t ret_ref = 0;
43611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43612 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43615 int64_t __attribute__((export_name("TS_Refund_clone_ptr"))) TS_Refund_clone_ptr(uint64_t arg) {
43616 LDKRefund arg_conv;
43617 arg_conv.inner = untag_ptr(arg);
43618 arg_conv.is_owned = ptr_is_owned(arg);
43619 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43620 arg_conv.is_owned = false;
43621 int64_t ret_conv = Refund_clone_ptr(&arg_conv);
43625 uint64_t __attribute__((export_name("TS_Refund_clone"))) TS_Refund_clone(uint64_t orig) {
43626 LDKRefund orig_conv;
43627 orig_conv.inner = untag_ptr(orig);
43628 orig_conv.is_owned = ptr_is_owned(orig);
43629 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43630 orig_conv.is_owned = false;
43631 LDKRefund ret_var = Refund_clone(&orig_conv);
43632 uint64_t ret_ref = 0;
43633 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43634 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43638 uint64_t __attribute__((export_name("TS_Refund_description"))) TS_Refund_description(uint64_t this_arg) {
43639 LDKRefund this_arg_conv;
43640 this_arg_conv.inner = untag_ptr(this_arg);
43641 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43643 this_arg_conv.is_owned = false;
43644 LDKPrintableString ret_var = Refund_description(&this_arg_conv);
43645 uint64_t ret_ref = 0;
43646 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43647 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43651 uint64_t __attribute__((export_name("TS_Refund_absolute_expiry"))) TS_Refund_absolute_expiry(uint64_t this_arg) {
43652 LDKRefund this_arg_conv;
43653 this_arg_conv.inner = untag_ptr(this_arg);
43654 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43656 this_arg_conv.is_owned = false;
43657 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
43658 *ret_copy = Refund_absolute_expiry(&this_arg_conv);
43659 uint64_t ret_ref = tag_ptr(ret_copy, true);
43663 uint64_t __attribute__((export_name("TS_Refund_issuer"))) TS_Refund_issuer(uint64_t this_arg) {
43664 LDKRefund this_arg_conv;
43665 this_arg_conv.inner = untag_ptr(this_arg);
43666 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43668 this_arg_conv.is_owned = false;
43669 LDKPrintableString ret_var = Refund_issuer(&this_arg_conv);
43670 uint64_t ret_ref = 0;
43671 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43672 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43676 uint64_tArray __attribute__((export_name("TS_Refund_paths"))) TS_Refund_paths(uint64_t this_arg) {
43677 LDKRefund this_arg_conv;
43678 this_arg_conv.inner = untag_ptr(this_arg);
43679 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43681 this_arg_conv.is_owned = false;
43682 LDKCVec_BlindedPathZ ret_var = Refund_paths(&this_arg_conv);
43683 uint64_tArray ret_arr = NULL;
43684 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
43685 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
43686 for (size_t n = 0; n < ret_var.datalen; n++) {
43687 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
43688 uint64_t ret_conv_13_ref = 0;
43689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
43690 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
43691 ret_arr_ptr[n] = ret_conv_13_ref;
43694 FREE(ret_var.data);
43698 int8_tArray __attribute__((export_name("TS_Refund_metadata"))) TS_Refund_metadata(uint64_t this_arg) {
43699 LDKRefund this_arg_conv;
43700 this_arg_conv.inner = untag_ptr(this_arg);
43701 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43702 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43703 this_arg_conv.is_owned = false;
43704 LDKu8slice ret_var = Refund_metadata(&this_arg_conv);
43705 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43706 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43710 int8_tArray __attribute__((export_name("TS_Refund_chain"))) TS_Refund_chain(uint64_t this_arg) {
43711 LDKRefund this_arg_conv;
43712 this_arg_conv.inner = untag_ptr(this_arg);
43713 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43715 this_arg_conv.is_owned = false;
43716 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43717 memcpy(ret_arr->elems, Refund_chain(&this_arg_conv).data, 32);
43721 int64_t __attribute__((export_name("TS_Refund_amount_msats"))) TS_Refund_amount_msats(uint64_t this_arg) {
43722 LDKRefund this_arg_conv;
43723 this_arg_conv.inner = untag_ptr(this_arg);
43724 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43725 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43726 this_arg_conv.is_owned = false;
43727 int64_t ret_conv = Refund_amount_msats(&this_arg_conv);
43731 uint64_t __attribute__((export_name("TS_Refund_features"))) TS_Refund_features(uint64_t this_arg) {
43732 LDKRefund this_arg_conv;
43733 this_arg_conv.inner = untag_ptr(this_arg);
43734 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43735 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43736 this_arg_conv.is_owned = false;
43737 LDKInvoiceRequestFeatures ret_var = Refund_features(&this_arg_conv);
43738 uint64_t ret_ref = 0;
43739 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43740 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43744 uint64_t __attribute__((export_name("TS_Refund_quantity"))) TS_Refund_quantity(uint64_t this_arg) {
43745 LDKRefund this_arg_conv;
43746 this_arg_conv.inner = untag_ptr(this_arg);
43747 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43748 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43749 this_arg_conv.is_owned = false;
43750 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43751 *ret_copy = Refund_quantity(&this_arg_conv);
43752 uint64_t ret_ref = tag_ptr(ret_copy, true);
43756 int8_tArray __attribute__((export_name("TS_Refund_payer_id"))) TS_Refund_payer_id(uint64_t this_arg) {
43757 LDKRefund this_arg_conv;
43758 this_arg_conv.inner = untag_ptr(this_arg);
43759 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43761 this_arg_conv.is_owned = false;
43762 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43763 memcpy(ret_arr->elems, Refund_payer_id(&this_arg_conv).compressed_form, 33);
43767 uint64_t __attribute__((export_name("TS_Refund_payer_note"))) TS_Refund_payer_note(uint64_t this_arg) {
43768 LDKRefund this_arg_conv;
43769 this_arg_conv.inner = untag_ptr(this_arg);
43770 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43772 this_arg_conv.is_owned = false;
43773 LDKPrintableString ret_var = Refund_payer_note(&this_arg_conv);
43774 uint64_t ret_ref = 0;
43775 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43776 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43780 int8_tArray __attribute__((export_name("TS_Refund_write"))) TS_Refund_write(uint64_t obj) {
43781 LDKRefund obj_conv;
43782 obj_conv.inner = untag_ptr(obj);
43783 obj_conv.is_owned = ptr_is_owned(obj);
43784 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43785 obj_conv.is_owned = false;
43786 LDKCVec_u8Z ret_var = Refund_write(&obj_conv);
43787 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43788 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43789 CVec_u8Z_free(ret_var);
43793 uint32_t __attribute__((export_name("TS_UtxoLookupError_clone"))) TS_UtxoLookupError_clone(uint64_t orig) {
43794 LDKUtxoLookupError* orig_conv = (LDKUtxoLookupError*)untag_ptr(orig);
43795 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_clone(orig_conv));
43799 uint32_t __attribute__((export_name("TS_UtxoLookupError_unknown_chain"))) TS_UtxoLookupError_unknown_chain() {
43800 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_unknown_chain());
43804 uint32_t __attribute__((export_name("TS_UtxoLookupError_unknown_tx"))) TS_UtxoLookupError_unknown_tx() {
43805 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_unknown_tx());
43809 void __attribute__((export_name("TS_UtxoResult_free"))) TS_UtxoResult_free(uint64_t this_ptr) {
43810 if (!ptr_is_owned(this_ptr)) return;
43811 void* this_ptr_ptr = untag_ptr(this_ptr);
43812 CHECK_ACCESS(this_ptr_ptr);
43813 LDKUtxoResult this_ptr_conv = *(LDKUtxoResult*)(this_ptr_ptr);
43814 FREE(untag_ptr(this_ptr));
43815 UtxoResult_free(this_ptr_conv);
43818 static inline uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg) {
43819 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43820 *ret_copy = UtxoResult_clone(arg);
43821 uint64_t ret_ref = tag_ptr(ret_copy, true);
43824 int64_t __attribute__((export_name("TS_UtxoResult_clone_ptr"))) TS_UtxoResult_clone_ptr(uint64_t arg) {
43825 LDKUtxoResult* arg_conv = (LDKUtxoResult*)untag_ptr(arg);
43826 int64_t ret_conv = UtxoResult_clone_ptr(arg_conv);
43830 uint64_t __attribute__((export_name("TS_UtxoResult_clone"))) TS_UtxoResult_clone(uint64_t orig) {
43831 LDKUtxoResult* orig_conv = (LDKUtxoResult*)untag_ptr(orig);
43832 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43833 *ret_copy = UtxoResult_clone(orig_conv);
43834 uint64_t ret_ref = tag_ptr(ret_copy, true);
43838 uint64_t __attribute__((export_name("TS_UtxoResult_sync"))) TS_UtxoResult_sync(uint64_t a) {
43839 void* a_ptr = untag_ptr(a);
43840 CHECK_ACCESS(a_ptr);
43841 LDKCResult_TxOutUtxoLookupErrorZ a_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(a_ptr);
43842 a_conv = CResult_TxOutUtxoLookupErrorZ_clone((LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(a));
43843 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43844 *ret_copy = UtxoResult_sync(a_conv);
43845 uint64_t ret_ref = tag_ptr(ret_copy, true);
43849 uint64_t __attribute__((export_name("TS_UtxoResult_async"))) TS_UtxoResult_async(uint64_t a) {
43850 LDKUtxoFuture a_conv;
43851 a_conv.inner = untag_ptr(a);
43852 a_conv.is_owned = ptr_is_owned(a);
43853 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43854 a_conv = UtxoFuture_clone(&a_conv);
43855 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43856 *ret_copy = UtxoResult_async(a_conv);
43857 uint64_t ret_ref = tag_ptr(ret_copy, true);
43861 void __attribute__((export_name("TS_UtxoLookup_free"))) TS_UtxoLookup_free(uint64_t this_ptr) {
43862 if (!ptr_is_owned(this_ptr)) return;
43863 void* this_ptr_ptr = untag_ptr(this_ptr);
43864 CHECK_ACCESS(this_ptr_ptr);
43865 LDKUtxoLookup this_ptr_conv = *(LDKUtxoLookup*)(this_ptr_ptr);
43866 FREE(untag_ptr(this_ptr));
43867 UtxoLookup_free(this_ptr_conv);
43870 void __attribute__((export_name("TS_UtxoFuture_free"))) TS_UtxoFuture_free(uint64_t this_obj) {
43871 LDKUtxoFuture this_obj_conv;
43872 this_obj_conv.inner = untag_ptr(this_obj);
43873 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43874 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43875 UtxoFuture_free(this_obj_conv);
43878 static inline uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg) {
43879 LDKUtxoFuture ret_var = UtxoFuture_clone(arg);
43880 uint64_t ret_ref = 0;
43881 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43882 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43885 int64_t __attribute__((export_name("TS_UtxoFuture_clone_ptr"))) TS_UtxoFuture_clone_ptr(uint64_t arg) {
43886 LDKUtxoFuture arg_conv;
43887 arg_conv.inner = untag_ptr(arg);
43888 arg_conv.is_owned = ptr_is_owned(arg);
43889 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43890 arg_conv.is_owned = false;
43891 int64_t ret_conv = UtxoFuture_clone_ptr(&arg_conv);
43895 uint64_t __attribute__((export_name("TS_UtxoFuture_clone"))) TS_UtxoFuture_clone(uint64_t orig) {
43896 LDKUtxoFuture orig_conv;
43897 orig_conv.inner = untag_ptr(orig);
43898 orig_conv.is_owned = ptr_is_owned(orig);
43899 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43900 orig_conv.is_owned = false;
43901 LDKUtxoFuture ret_var = UtxoFuture_clone(&orig_conv);
43902 uint64_t ret_ref = 0;
43903 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43904 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43908 uint64_t __attribute__((export_name("TS_UtxoFuture_new"))) TS_UtxoFuture_new() {
43909 LDKUtxoFuture ret_var = UtxoFuture_new();
43910 uint64_t ret_ref = 0;
43911 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43912 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43916 void __attribute__((export_name("TS_UtxoFuture_resolve_without_forwarding"))) TS_UtxoFuture_resolve_without_forwarding(uint64_t this_arg, uint64_t graph, uint64_t result) {
43917 LDKUtxoFuture this_arg_conv;
43918 this_arg_conv.inner = untag_ptr(this_arg);
43919 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43921 this_arg_conv.is_owned = false;
43922 LDKNetworkGraph graph_conv;
43923 graph_conv.inner = untag_ptr(graph);
43924 graph_conv.is_owned = ptr_is_owned(graph);
43925 CHECK_INNER_FIELD_ACCESS_OR_NULL(graph_conv);
43926 graph_conv.is_owned = false;
43927 void* result_ptr = untag_ptr(result);
43928 CHECK_ACCESS(result_ptr);
43929 LDKCResult_TxOutUtxoLookupErrorZ result_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(result_ptr);
43930 UtxoFuture_resolve_without_forwarding(&this_arg_conv, &graph_conv, result_conv);
43933 void __attribute__((export_name("TS_UtxoFuture_resolve"))) TS_UtxoFuture_resolve(uint64_t this_arg, uint64_t graph, uint64_t gossip, uint64_t result) {
43934 LDKUtxoFuture this_arg_conv;
43935 this_arg_conv.inner = untag_ptr(this_arg);
43936 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43938 this_arg_conv.is_owned = false;
43939 LDKNetworkGraph graph_conv;
43940 graph_conv.inner = untag_ptr(graph);
43941 graph_conv.is_owned = ptr_is_owned(graph);
43942 CHECK_INNER_FIELD_ACCESS_OR_NULL(graph_conv);
43943 graph_conv.is_owned = false;
43944 LDKP2PGossipSync gossip_conv;
43945 gossip_conv.inner = untag_ptr(gossip);
43946 gossip_conv.is_owned = ptr_is_owned(gossip);
43947 CHECK_INNER_FIELD_ACCESS_OR_NULL(gossip_conv);
43948 gossip_conv.is_owned = false;
43949 void* result_ptr = untag_ptr(result);
43950 CHECK_ACCESS(result_ptr);
43951 LDKCResult_TxOutUtxoLookupErrorZ result_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(result_ptr);
43952 UtxoFuture_resolve(&this_arg_conv, &graph_conv, &gossip_conv, result_conv);
43955 void __attribute__((export_name("TS_NodeId_free"))) TS_NodeId_free(uint64_t this_obj) {
43956 LDKNodeId this_obj_conv;
43957 this_obj_conv.inner = untag_ptr(this_obj);
43958 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43960 NodeId_free(this_obj_conv);
43963 static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
43964 LDKNodeId ret_var = NodeId_clone(arg);
43965 uint64_t ret_ref = 0;
43966 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43967 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43970 int64_t __attribute__((export_name("TS_NodeId_clone_ptr"))) TS_NodeId_clone_ptr(uint64_t arg) {
43971 LDKNodeId arg_conv;
43972 arg_conv.inner = untag_ptr(arg);
43973 arg_conv.is_owned = ptr_is_owned(arg);
43974 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43975 arg_conv.is_owned = false;
43976 int64_t ret_conv = NodeId_clone_ptr(&arg_conv);
43980 uint64_t __attribute__((export_name("TS_NodeId_clone"))) TS_NodeId_clone(uint64_t orig) {
43981 LDKNodeId orig_conv;
43982 orig_conv.inner = untag_ptr(orig);
43983 orig_conv.is_owned = ptr_is_owned(orig);
43984 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43985 orig_conv.is_owned = false;
43986 LDKNodeId ret_var = NodeId_clone(&orig_conv);
43987 uint64_t ret_ref = 0;
43988 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43989 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43993 uint64_t __attribute__((export_name("TS_NodeId_from_pubkey"))) TS_NodeId_from_pubkey(int8_tArray pubkey) {
43994 LDKPublicKey pubkey_ref;
43995 CHECK(pubkey->arr_len == 33);
43996 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
43997 LDKNodeId ret_var = NodeId_from_pubkey(pubkey_ref);
43998 uint64_t ret_ref = 0;
43999 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44000 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44004 int8_tArray __attribute__((export_name("TS_NodeId_as_slice"))) TS_NodeId_as_slice(uint64_t this_arg) {
44005 LDKNodeId this_arg_conv;
44006 this_arg_conv.inner = untag_ptr(this_arg);
44007 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44009 this_arg_conv.is_owned = false;
44010 LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
44011 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44012 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44016 uint64_t __attribute__((export_name("TS_NodeId_as_pubkey"))) TS_NodeId_as_pubkey(uint64_t this_arg) {
44017 LDKNodeId this_arg_conv;
44018 this_arg_conv.inner = untag_ptr(this_arg);
44019 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44021 this_arg_conv.is_owned = false;
44022 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
44023 *ret_conv = NodeId_as_pubkey(&this_arg_conv);
44024 return tag_ptr(ret_conv, true);
44027 int64_t __attribute__((export_name("TS_NodeId_hash"))) TS_NodeId_hash(uint64_t o) {
44029 o_conv.inner = untag_ptr(o);
44030 o_conv.is_owned = ptr_is_owned(o);
44031 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44032 o_conv.is_owned = false;
44033 int64_t ret_conv = NodeId_hash(&o_conv);
44037 int8_tArray __attribute__((export_name("TS_NodeId_write"))) TS_NodeId_write(uint64_t obj) {
44038 LDKNodeId obj_conv;
44039 obj_conv.inner = untag_ptr(obj);
44040 obj_conv.is_owned = ptr_is_owned(obj);
44041 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44042 obj_conv.is_owned = false;
44043 LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
44044 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44045 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44046 CVec_u8Z_free(ret_var);
44050 uint64_t __attribute__((export_name("TS_NodeId_read"))) TS_NodeId_read(int8_tArray ser) {
44051 LDKu8slice ser_ref;
44052 ser_ref.datalen = ser->arr_len;
44053 ser_ref.data = ser->elems;
44054 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
44055 *ret_conv = NodeId_read(ser_ref);
44057 return tag_ptr(ret_conv, true);
44060 void __attribute__((export_name("TS_NetworkGraph_free"))) TS_NetworkGraph_free(uint64_t this_obj) {
44061 LDKNetworkGraph this_obj_conv;
44062 this_obj_conv.inner = untag_ptr(this_obj);
44063 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44064 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44065 NetworkGraph_free(this_obj_conv);
44068 void __attribute__((export_name("TS_ReadOnlyNetworkGraph_free"))) TS_ReadOnlyNetworkGraph_free(uint64_t this_obj) {
44069 LDKReadOnlyNetworkGraph this_obj_conv;
44070 this_obj_conv.inner = untag_ptr(this_obj);
44071 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44072 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44073 ReadOnlyNetworkGraph_free(this_obj_conv);
44076 void __attribute__((export_name("TS_NetworkUpdate_free"))) TS_NetworkUpdate_free(uint64_t this_ptr) {
44077 if (!ptr_is_owned(this_ptr)) return;
44078 void* this_ptr_ptr = untag_ptr(this_ptr);
44079 CHECK_ACCESS(this_ptr_ptr);
44080 LDKNetworkUpdate this_ptr_conv = *(LDKNetworkUpdate*)(this_ptr_ptr);
44081 FREE(untag_ptr(this_ptr));
44082 NetworkUpdate_free(this_ptr_conv);
44085 static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
44086 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44087 *ret_copy = NetworkUpdate_clone(arg);
44088 uint64_t ret_ref = tag_ptr(ret_copy, true);
44091 int64_t __attribute__((export_name("TS_NetworkUpdate_clone_ptr"))) TS_NetworkUpdate_clone_ptr(uint64_t arg) {
44092 LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)untag_ptr(arg);
44093 int64_t ret_conv = NetworkUpdate_clone_ptr(arg_conv);
44097 uint64_t __attribute__((export_name("TS_NetworkUpdate_clone"))) TS_NetworkUpdate_clone(uint64_t orig) {
44098 LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)untag_ptr(orig);
44099 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44100 *ret_copy = NetworkUpdate_clone(orig_conv);
44101 uint64_t ret_ref = tag_ptr(ret_copy, true);
44105 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_update_message"))) TS_NetworkUpdate_channel_update_message(uint64_t msg) {
44106 LDKChannelUpdate msg_conv;
44107 msg_conv.inner = untag_ptr(msg);
44108 msg_conv.is_owned = ptr_is_owned(msg);
44109 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
44110 msg_conv = ChannelUpdate_clone(&msg_conv);
44111 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44112 *ret_copy = NetworkUpdate_channel_update_message(msg_conv);
44113 uint64_t ret_ref = tag_ptr(ret_copy, true);
44117 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_failure"))) TS_NetworkUpdate_channel_failure(int64_t short_channel_id, jboolean is_permanent) {
44118 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44119 *ret_copy = NetworkUpdate_channel_failure(short_channel_id, is_permanent);
44120 uint64_t ret_ref = tag_ptr(ret_copy, true);
44124 uint64_t __attribute__((export_name("TS_NetworkUpdate_node_failure"))) TS_NetworkUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) {
44125 LDKPublicKey node_id_ref;
44126 CHECK(node_id->arr_len == 33);
44127 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
44128 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44129 *ret_copy = NetworkUpdate_node_failure(node_id_ref, is_permanent);
44130 uint64_t ret_ref = tag_ptr(ret_copy, true);
44134 jboolean __attribute__((export_name("TS_NetworkUpdate_eq"))) TS_NetworkUpdate_eq(uint64_t a, uint64_t b) {
44135 LDKNetworkUpdate* a_conv = (LDKNetworkUpdate*)untag_ptr(a);
44136 LDKNetworkUpdate* b_conv = (LDKNetworkUpdate*)untag_ptr(b);
44137 jboolean ret_conv = NetworkUpdate_eq(a_conv, b_conv);
44141 int8_tArray __attribute__((export_name("TS_NetworkUpdate_write"))) TS_NetworkUpdate_write(uint64_t obj) {
44142 LDKNetworkUpdate* obj_conv = (LDKNetworkUpdate*)untag_ptr(obj);
44143 LDKCVec_u8Z ret_var = NetworkUpdate_write(obj_conv);
44144 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44145 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44146 CVec_u8Z_free(ret_var);
44150 uint64_t __attribute__((export_name("TS_NetworkUpdate_read"))) TS_NetworkUpdate_read(int8_tArray ser) {
44151 LDKu8slice ser_ref;
44152 ser_ref.datalen = ser->arr_len;
44153 ser_ref.data = ser->elems;
44154 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
44155 *ret_conv = NetworkUpdate_read(ser_ref);
44157 return tag_ptr(ret_conv, true);
44160 void __attribute__((export_name("TS_P2PGossipSync_free"))) TS_P2PGossipSync_free(uint64_t this_obj) {
44161 LDKP2PGossipSync this_obj_conv;
44162 this_obj_conv.inner = untag_ptr(this_obj);
44163 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44164 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44165 P2PGossipSync_free(this_obj_conv);
44168 uint64_t __attribute__((export_name("TS_P2PGossipSync_new"))) TS_P2PGossipSync_new(uint64_t network_graph, uint64_t utxo_lookup, uint64_t logger) {
44169 LDKNetworkGraph network_graph_conv;
44170 network_graph_conv.inner = untag_ptr(network_graph);
44171 network_graph_conv.is_owned = ptr_is_owned(network_graph);
44172 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
44173 network_graph_conv.is_owned = false;
44174 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
44175 CHECK_ACCESS(utxo_lookup_ptr);
44176 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
44177 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
44178 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
44179 // Manually implement clone for Java trait instances
44180 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
44181 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
44182 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
44185 void* logger_ptr = untag_ptr(logger);
44186 CHECK_ACCESS(logger_ptr);
44187 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
44188 if (logger_conv.free == LDKLogger_JCalls_free) {
44189 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
44190 LDKLogger_JCalls_cloned(&logger_conv);
44192 LDKP2PGossipSync ret_var = P2PGossipSync_new(&network_graph_conv, utxo_lookup_conv, logger_conv);
44193 uint64_t ret_ref = 0;
44194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44195 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44199 void __attribute__((export_name("TS_P2PGossipSync_add_utxo_lookup"))) TS_P2PGossipSync_add_utxo_lookup(uint64_t this_arg, uint64_t utxo_lookup) {
44200 LDKP2PGossipSync this_arg_conv;
44201 this_arg_conv.inner = untag_ptr(this_arg);
44202 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44204 this_arg_conv.is_owned = false;
44205 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
44206 CHECK_ACCESS(utxo_lookup_ptr);
44207 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
44208 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
44209 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
44210 // Manually implement clone for Java trait instances
44211 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
44212 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
44213 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
44216 P2PGossipSync_add_utxo_lookup(&this_arg_conv, utxo_lookup_conv);
44219 void __attribute__((export_name("TS_NetworkGraph_handle_network_update"))) TS_NetworkGraph_handle_network_update(uint64_t this_arg, uint64_t network_update) {
44220 LDKNetworkGraph this_arg_conv;
44221 this_arg_conv.inner = untag_ptr(this_arg);
44222 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44223 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44224 this_arg_conv.is_owned = false;
44225 LDKNetworkUpdate* network_update_conv = (LDKNetworkUpdate*)untag_ptr(network_update);
44226 NetworkGraph_handle_network_update(&this_arg_conv, network_update_conv);
44229 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_RoutingMessageHandler"))) TS_P2PGossipSync_as_RoutingMessageHandler(uint64_t this_arg) {
44230 LDKP2PGossipSync this_arg_conv;
44231 this_arg_conv.inner = untag_ptr(this_arg);
44232 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44234 this_arg_conv.is_owned = false;
44235 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
44236 *ret_ret = P2PGossipSync_as_RoutingMessageHandler(&this_arg_conv);
44237 return tag_ptr(ret_ret, true);
44240 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_MessageSendEventsProvider"))) TS_P2PGossipSync_as_MessageSendEventsProvider(uint64_t this_arg) {
44241 LDKP2PGossipSync this_arg_conv;
44242 this_arg_conv.inner = untag_ptr(this_arg);
44243 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44245 this_arg_conv.is_owned = false;
44246 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
44247 *ret_ret = P2PGossipSync_as_MessageSendEventsProvider(&this_arg_conv);
44248 return tag_ptr(ret_ret, true);
44251 void __attribute__((export_name("TS_ChannelUpdateInfo_free"))) TS_ChannelUpdateInfo_free(uint64_t this_obj) {
44252 LDKChannelUpdateInfo this_obj_conv;
44253 this_obj_conv.inner = untag_ptr(this_obj);
44254 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44256 ChannelUpdateInfo_free(this_obj_conv);
44259 int32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update"))) TS_ChannelUpdateInfo_get_last_update(uint64_t this_ptr) {
44260 LDKChannelUpdateInfo this_ptr_conv;
44261 this_ptr_conv.inner = untag_ptr(this_ptr);
44262 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44264 this_ptr_conv.is_owned = false;
44265 int32_t ret_conv = ChannelUpdateInfo_get_last_update(&this_ptr_conv);
44269 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update"))) TS_ChannelUpdateInfo_set_last_update(uint64_t this_ptr, int32_t val) {
44270 LDKChannelUpdateInfo this_ptr_conv;
44271 this_ptr_conv.inner = untag_ptr(this_ptr);
44272 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44274 this_ptr_conv.is_owned = false;
44275 ChannelUpdateInfo_set_last_update(&this_ptr_conv, val);
44278 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_get_enabled"))) TS_ChannelUpdateInfo_get_enabled(uint64_t this_ptr) {
44279 LDKChannelUpdateInfo this_ptr_conv;
44280 this_ptr_conv.inner = untag_ptr(this_ptr);
44281 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44282 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44283 this_ptr_conv.is_owned = false;
44284 jboolean ret_conv = ChannelUpdateInfo_get_enabled(&this_ptr_conv);
44288 void __attribute__((export_name("TS_ChannelUpdateInfo_set_enabled"))) TS_ChannelUpdateInfo_set_enabled(uint64_t this_ptr, jboolean val) {
44289 LDKChannelUpdateInfo this_ptr_conv;
44290 this_ptr_conv.inner = untag_ptr(this_ptr);
44291 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44292 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44293 this_ptr_conv.is_owned = false;
44294 ChannelUpdateInfo_set_enabled(&this_ptr_conv, val);
44297 int16_t __attribute__((export_name("TS_ChannelUpdateInfo_get_cltv_expiry_delta"))) TS_ChannelUpdateInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
44298 LDKChannelUpdateInfo this_ptr_conv;
44299 this_ptr_conv.inner = untag_ptr(this_ptr);
44300 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44301 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44302 this_ptr_conv.is_owned = false;
44303 int16_t ret_conv = ChannelUpdateInfo_get_cltv_expiry_delta(&this_ptr_conv);
44307 void __attribute__((export_name("TS_ChannelUpdateInfo_set_cltv_expiry_delta"))) TS_ChannelUpdateInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
44308 LDKChannelUpdateInfo this_ptr_conv;
44309 this_ptr_conv.inner = untag_ptr(this_ptr);
44310 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44311 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44312 this_ptr_conv.is_owned = false;
44313 ChannelUpdateInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
44316 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_minimum_msat"))) TS_ChannelUpdateInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
44317 LDKChannelUpdateInfo this_ptr_conv;
44318 this_ptr_conv.inner = untag_ptr(this_ptr);
44319 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44321 this_ptr_conv.is_owned = false;
44322 int64_t ret_conv = ChannelUpdateInfo_get_htlc_minimum_msat(&this_ptr_conv);
44326 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_minimum_msat"))) TS_ChannelUpdateInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
44327 LDKChannelUpdateInfo this_ptr_conv;
44328 this_ptr_conv.inner = untag_ptr(this_ptr);
44329 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44330 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44331 this_ptr_conv.is_owned = false;
44332 ChannelUpdateInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
44335 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_maximum_msat"))) TS_ChannelUpdateInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
44336 LDKChannelUpdateInfo this_ptr_conv;
44337 this_ptr_conv.inner = untag_ptr(this_ptr);
44338 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44339 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44340 this_ptr_conv.is_owned = false;
44341 int64_t ret_conv = ChannelUpdateInfo_get_htlc_maximum_msat(&this_ptr_conv);
44345 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_maximum_msat"))) TS_ChannelUpdateInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
44346 LDKChannelUpdateInfo this_ptr_conv;
44347 this_ptr_conv.inner = untag_ptr(this_ptr);
44348 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44349 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44350 this_ptr_conv.is_owned = false;
44351 ChannelUpdateInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
44354 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_fees"))) TS_ChannelUpdateInfo_get_fees(uint64_t this_ptr) {
44355 LDKChannelUpdateInfo 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 LDKRoutingFees ret_var = ChannelUpdateInfo_get_fees(&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_ChannelUpdateInfo_set_fees"))) TS_ChannelUpdateInfo_set_fees(uint64_t this_ptr, uint64_t val) {
44368 LDKChannelUpdateInfo 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 LDKRoutingFees 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 = RoutingFees_clone(&val_conv);
44378 ChannelUpdateInfo_set_fees(&this_ptr_conv, val_conv);
44381 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update_message"))) TS_ChannelUpdateInfo_get_last_update_message(uint64_t this_ptr) {
44382 LDKChannelUpdateInfo 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 LDKChannelUpdate ret_var = ChannelUpdateInfo_get_last_update_message(&this_ptr_conv);
44388 uint64_t ret_ref = 0;
44389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44394 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update_message"))) TS_ChannelUpdateInfo_set_last_update_message(uint64_t this_ptr, uint64_t val) {
44395 LDKChannelUpdateInfo this_ptr_conv;
44396 this_ptr_conv.inner = untag_ptr(this_ptr);
44397 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44399 this_ptr_conv.is_owned = false;
44400 LDKChannelUpdate val_conv;
44401 val_conv.inner = untag_ptr(val);
44402 val_conv.is_owned = ptr_is_owned(val);
44403 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44404 val_conv = ChannelUpdate_clone(&val_conv);
44405 ChannelUpdateInfo_set_last_update_message(&this_ptr_conv, val_conv);
44408 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) {
44409 LDKRoutingFees fees_arg_conv;
44410 fees_arg_conv.inner = untag_ptr(fees_arg);
44411 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
44412 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
44413 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
44414 LDKChannelUpdate last_update_message_arg_conv;
44415 last_update_message_arg_conv.inner = untag_ptr(last_update_message_arg);
44416 last_update_message_arg_conv.is_owned = ptr_is_owned(last_update_message_arg);
44417 CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
44418 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
44419 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);
44420 uint64_t ret_ref = 0;
44421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44426 static inline uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg) {
44427 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(arg);
44428 uint64_t ret_ref = 0;
44429 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44430 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44433 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone_ptr"))) TS_ChannelUpdateInfo_clone_ptr(uint64_t arg) {
44434 LDKChannelUpdateInfo arg_conv;
44435 arg_conv.inner = untag_ptr(arg);
44436 arg_conv.is_owned = ptr_is_owned(arg);
44437 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44438 arg_conv.is_owned = false;
44439 int64_t ret_conv = ChannelUpdateInfo_clone_ptr(&arg_conv);
44443 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone"))) TS_ChannelUpdateInfo_clone(uint64_t orig) {
44444 LDKChannelUpdateInfo orig_conv;
44445 orig_conv.inner = untag_ptr(orig);
44446 orig_conv.is_owned = ptr_is_owned(orig);
44447 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44448 orig_conv.is_owned = false;
44449 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(&orig_conv);
44450 uint64_t ret_ref = 0;
44451 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44452 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44456 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_eq"))) TS_ChannelUpdateInfo_eq(uint64_t a, uint64_t b) {
44457 LDKChannelUpdateInfo a_conv;
44458 a_conv.inner = untag_ptr(a);
44459 a_conv.is_owned = ptr_is_owned(a);
44460 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44461 a_conv.is_owned = false;
44462 LDKChannelUpdateInfo b_conv;
44463 b_conv.inner = untag_ptr(b);
44464 b_conv.is_owned = ptr_is_owned(b);
44465 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44466 b_conv.is_owned = false;
44467 jboolean ret_conv = ChannelUpdateInfo_eq(&a_conv, &b_conv);
44471 int8_tArray __attribute__((export_name("TS_ChannelUpdateInfo_write"))) TS_ChannelUpdateInfo_write(uint64_t obj) {
44472 LDKChannelUpdateInfo obj_conv;
44473 obj_conv.inner = untag_ptr(obj);
44474 obj_conv.is_owned = ptr_is_owned(obj);
44475 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44476 obj_conv.is_owned = false;
44477 LDKCVec_u8Z ret_var = ChannelUpdateInfo_write(&obj_conv);
44478 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44479 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44480 CVec_u8Z_free(ret_var);
44484 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_read"))) TS_ChannelUpdateInfo_read(int8_tArray ser) {
44485 LDKu8slice ser_ref;
44486 ser_ref.datalen = ser->arr_len;
44487 ser_ref.data = ser->elems;
44488 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
44489 *ret_conv = ChannelUpdateInfo_read(ser_ref);
44491 return tag_ptr(ret_conv, true);
44494 void __attribute__((export_name("TS_ChannelInfo_free"))) TS_ChannelInfo_free(uint64_t this_obj) {
44495 LDKChannelInfo this_obj_conv;
44496 this_obj_conv.inner = untag_ptr(this_obj);
44497 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44499 ChannelInfo_free(this_obj_conv);
44502 uint64_t __attribute__((export_name("TS_ChannelInfo_get_features"))) TS_ChannelInfo_get_features(uint64_t this_ptr) {
44503 LDKChannelInfo 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 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
44509 uint64_t ret_ref = 0;
44510 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44511 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44515 void __attribute__((export_name("TS_ChannelInfo_set_features"))) TS_ChannelInfo_set_features(uint64_t this_ptr, uint64_t val) {
44516 LDKChannelInfo this_ptr_conv;
44517 this_ptr_conv.inner = untag_ptr(this_ptr);
44518 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44520 this_ptr_conv.is_owned = false;
44521 LDKChannelFeatures val_conv;
44522 val_conv.inner = untag_ptr(val);
44523 val_conv.is_owned = ptr_is_owned(val);
44524 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44525 val_conv = ChannelFeatures_clone(&val_conv);
44526 ChannelInfo_set_features(&this_ptr_conv, val_conv);
44529 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_one"))) TS_ChannelInfo_get_node_one(uint64_t this_ptr) {
44530 LDKChannelInfo this_ptr_conv;
44531 this_ptr_conv.inner = untag_ptr(this_ptr);
44532 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44533 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44534 this_ptr_conv.is_owned = false;
44535 LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
44536 uint64_t ret_ref = 0;
44537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44542 void __attribute__((export_name("TS_ChannelInfo_set_node_one"))) TS_ChannelInfo_set_node_one(uint64_t this_ptr, uint64_t val) {
44543 LDKChannelInfo this_ptr_conv;
44544 this_ptr_conv.inner = untag_ptr(this_ptr);
44545 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44547 this_ptr_conv.is_owned = false;
44548 LDKNodeId val_conv;
44549 val_conv.inner = untag_ptr(val);
44550 val_conv.is_owned = ptr_is_owned(val);
44551 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44552 val_conv = NodeId_clone(&val_conv);
44553 ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
44556 uint64_t __attribute__((export_name("TS_ChannelInfo_get_one_to_two"))) TS_ChannelInfo_get_one_to_two(uint64_t this_ptr) {
44557 LDKChannelInfo this_ptr_conv;
44558 this_ptr_conv.inner = untag_ptr(this_ptr);
44559 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44560 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44561 this_ptr_conv.is_owned = false;
44562 LDKChannelUpdateInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
44563 uint64_t ret_ref = 0;
44564 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44565 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44569 void __attribute__((export_name("TS_ChannelInfo_set_one_to_two"))) TS_ChannelInfo_set_one_to_two(uint64_t this_ptr, uint64_t val) {
44570 LDKChannelInfo this_ptr_conv;
44571 this_ptr_conv.inner = untag_ptr(this_ptr);
44572 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44574 this_ptr_conv.is_owned = false;
44575 LDKChannelUpdateInfo val_conv;
44576 val_conv.inner = untag_ptr(val);
44577 val_conv.is_owned = ptr_is_owned(val);
44578 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44579 val_conv = ChannelUpdateInfo_clone(&val_conv);
44580 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
44583 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_two"))) TS_ChannelInfo_get_node_two(uint64_t this_ptr) {
44584 LDKChannelInfo this_ptr_conv;
44585 this_ptr_conv.inner = untag_ptr(this_ptr);
44586 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44588 this_ptr_conv.is_owned = false;
44589 LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
44590 uint64_t ret_ref = 0;
44591 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44592 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44596 void __attribute__((export_name("TS_ChannelInfo_set_node_two"))) TS_ChannelInfo_set_node_two(uint64_t this_ptr, uint64_t val) {
44597 LDKChannelInfo this_ptr_conv;
44598 this_ptr_conv.inner = untag_ptr(this_ptr);
44599 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44601 this_ptr_conv.is_owned = false;
44602 LDKNodeId val_conv;
44603 val_conv.inner = untag_ptr(val);
44604 val_conv.is_owned = ptr_is_owned(val);
44605 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44606 val_conv = NodeId_clone(&val_conv);
44607 ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
44610 uint64_t __attribute__((export_name("TS_ChannelInfo_get_two_to_one"))) TS_ChannelInfo_get_two_to_one(uint64_t this_ptr) {
44611 LDKChannelInfo this_ptr_conv;
44612 this_ptr_conv.inner = untag_ptr(this_ptr);
44613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44615 this_ptr_conv.is_owned = false;
44616 LDKChannelUpdateInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
44617 uint64_t ret_ref = 0;
44618 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44619 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44623 void __attribute__((export_name("TS_ChannelInfo_set_two_to_one"))) TS_ChannelInfo_set_two_to_one(uint64_t this_ptr, uint64_t val) {
44624 LDKChannelInfo this_ptr_conv;
44625 this_ptr_conv.inner = untag_ptr(this_ptr);
44626 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44628 this_ptr_conv.is_owned = false;
44629 LDKChannelUpdateInfo val_conv;
44630 val_conv.inner = untag_ptr(val);
44631 val_conv.is_owned = ptr_is_owned(val);
44632 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44633 val_conv = ChannelUpdateInfo_clone(&val_conv);
44634 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
44637 uint64_t __attribute__((export_name("TS_ChannelInfo_get_capacity_sats"))) TS_ChannelInfo_get_capacity_sats(uint64_t this_ptr) {
44638 LDKChannelInfo this_ptr_conv;
44639 this_ptr_conv.inner = untag_ptr(this_ptr);
44640 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44641 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44642 this_ptr_conv.is_owned = false;
44643 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
44644 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
44645 uint64_t ret_ref = tag_ptr(ret_copy, true);
44649 void __attribute__((export_name("TS_ChannelInfo_set_capacity_sats"))) TS_ChannelInfo_set_capacity_sats(uint64_t this_ptr, uint64_t val) {
44650 LDKChannelInfo this_ptr_conv;
44651 this_ptr_conv.inner = untag_ptr(this_ptr);
44652 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44654 this_ptr_conv.is_owned = false;
44655 void* val_ptr = untag_ptr(val);
44656 CHECK_ACCESS(val_ptr);
44657 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
44658 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
44659 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
44662 uint64_t __attribute__((export_name("TS_ChannelInfo_get_announcement_message"))) TS_ChannelInfo_get_announcement_message(uint64_t this_ptr) {
44663 LDKChannelInfo this_ptr_conv;
44664 this_ptr_conv.inner = untag_ptr(this_ptr);
44665 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44667 this_ptr_conv.is_owned = false;
44668 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
44669 uint64_t ret_ref = 0;
44670 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44671 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44675 void __attribute__((export_name("TS_ChannelInfo_set_announcement_message"))) TS_ChannelInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
44676 LDKChannelInfo this_ptr_conv;
44677 this_ptr_conv.inner = untag_ptr(this_ptr);
44678 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44679 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44680 this_ptr_conv.is_owned = false;
44681 LDKChannelAnnouncement val_conv;
44682 val_conv.inner = untag_ptr(val);
44683 val_conv.is_owned = ptr_is_owned(val);
44684 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44685 val_conv = ChannelAnnouncement_clone(&val_conv);
44686 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
44689 static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
44690 LDKChannelInfo ret_var = ChannelInfo_clone(arg);
44691 uint64_t ret_ref = 0;
44692 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44693 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44696 int64_t __attribute__((export_name("TS_ChannelInfo_clone_ptr"))) TS_ChannelInfo_clone_ptr(uint64_t arg) {
44697 LDKChannelInfo arg_conv;
44698 arg_conv.inner = untag_ptr(arg);
44699 arg_conv.is_owned = ptr_is_owned(arg);
44700 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44701 arg_conv.is_owned = false;
44702 int64_t ret_conv = ChannelInfo_clone_ptr(&arg_conv);
44706 uint64_t __attribute__((export_name("TS_ChannelInfo_clone"))) TS_ChannelInfo_clone(uint64_t orig) {
44707 LDKChannelInfo orig_conv;
44708 orig_conv.inner = untag_ptr(orig);
44709 orig_conv.is_owned = ptr_is_owned(orig);
44710 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44711 orig_conv.is_owned = false;
44712 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
44713 uint64_t ret_ref = 0;
44714 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44715 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44719 jboolean __attribute__((export_name("TS_ChannelInfo_eq"))) TS_ChannelInfo_eq(uint64_t a, uint64_t b) {
44720 LDKChannelInfo a_conv;
44721 a_conv.inner = untag_ptr(a);
44722 a_conv.is_owned = ptr_is_owned(a);
44723 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44724 a_conv.is_owned = false;
44725 LDKChannelInfo b_conv;
44726 b_conv.inner = untag_ptr(b);
44727 b_conv.is_owned = ptr_is_owned(b);
44728 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44729 b_conv.is_owned = false;
44730 jboolean ret_conv = ChannelInfo_eq(&a_conv, &b_conv);
44734 uint64_t __attribute__((export_name("TS_ChannelInfo_get_directional_info"))) TS_ChannelInfo_get_directional_info(uint64_t this_arg, int8_t channel_flags) {
44735 LDKChannelInfo this_arg_conv;
44736 this_arg_conv.inner = untag_ptr(this_arg);
44737 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44739 this_arg_conv.is_owned = false;
44740 LDKChannelUpdateInfo ret_var = ChannelInfo_get_directional_info(&this_arg_conv, channel_flags);
44741 uint64_t ret_ref = 0;
44742 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44743 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44747 int8_tArray __attribute__((export_name("TS_ChannelInfo_write"))) TS_ChannelInfo_write(uint64_t obj) {
44748 LDKChannelInfo obj_conv;
44749 obj_conv.inner = untag_ptr(obj);
44750 obj_conv.is_owned = ptr_is_owned(obj);
44751 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44752 obj_conv.is_owned = false;
44753 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
44754 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44755 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44756 CVec_u8Z_free(ret_var);
44760 uint64_t __attribute__((export_name("TS_ChannelInfo_read"))) TS_ChannelInfo_read(int8_tArray ser) {
44761 LDKu8slice ser_ref;
44762 ser_ref.datalen = ser->arr_len;
44763 ser_ref.data = ser->elems;
44764 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
44765 *ret_conv = ChannelInfo_read(ser_ref);
44767 return tag_ptr(ret_conv, true);
44770 void __attribute__((export_name("TS_DirectedChannelInfo_free"))) TS_DirectedChannelInfo_free(uint64_t this_obj) {
44771 LDKDirectedChannelInfo this_obj_conv;
44772 this_obj_conv.inner = untag_ptr(this_obj);
44773 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44775 DirectedChannelInfo_free(this_obj_conv);
44778 static inline uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg) {
44779 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(arg);
44780 uint64_t ret_ref = 0;
44781 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44782 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44785 int64_t __attribute__((export_name("TS_DirectedChannelInfo_clone_ptr"))) TS_DirectedChannelInfo_clone_ptr(uint64_t arg) {
44786 LDKDirectedChannelInfo arg_conv;
44787 arg_conv.inner = untag_ptr(arg);
44788 arg_conv.is_owned = ptr_is_owned(arg);
44789 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44790 arg_conv.is_owned = false;
44791 int64_t ret_conv = DirectedChannelInfo_clone_ptr(&arg_conv);
44795 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_clone"))) TS_DirectedChannelInfo_clone(uint64_t orig) {
44796 LDKDirectedChannelInfo orig_conv;
44797 orig_conv.inner = untag_ptr(orig);
44798 orig_conv.is_owned = ptr_is_owned(orig);
44799 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44800 orig_conv.is_owned = false;
44801 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(&orig_conv);
44802 uint64_t ret_ref = 0;
44803 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44804 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44808 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_channel"))) TS_DirectedChannelInfo_channel(uint64_t this_arg) {
44809 LDKDirectedChannelInfo this_arg_conv;
44810 this_arg_conv.inner = untag_ptr(this_arg);
44811 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44812 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44813 this_arg_conv.is_owned = false;
44814 LDKChannelInfo ret_var = DirectedChannelInfo_channel(&this_arg_conv);
44815 uint64_t ret_ref = 0;
44816 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44817 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44821 int64_t __attribute__((export_name("TS_DirectedChannelInfo_htlc_maximum_msat"))) TS_DirectedChannelInfo_htlc_maximum_msat(uint64_t this_arg) {
44822 LDKDirectedChannelInfo this_arg_conv;
44823 this_arg_conv.inner = untag_ptr(this_arg);
44824 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44826 this_arg_conv.is_owned = false;
44827 int64_t ret_conv = DirectedChannelInfo_htlc_maximum_msat(&this_arg_conv);
44831 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_effective_capacity"))) TS_DirectedChannelInfo_effective_capacity(uint64_t this_arg) {
44832 LDKDirectedChannelInfo this_arg_conv;
44833 this_arg_conv.inner = untag_ptr(this_arg);
44834 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44835 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44836 this_arg_conv.is_owned = false;
44837 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44838 *ret_copy = DirectedChannelInfo_effective_capacity(&this_arg_conv);
44839 uint64_t ret_ref = tag_ptr(ret_copy, true);
44843 void __attribute__((export_name("TS_EffectiveCapacity_free"))) TS_EffectiveCapacity_free(uint64_t this_ptr) {
44844 if (!ptr_is_owned(this_ptr)) return;
44845 void* this_ptr_ptr = untag_ptr(this_ptr);
44846 CHECK_ACCESS(this_ptr_ptr);
44847 LDKEffectiveCapacity this_ptr_conv = *(LDKEffectiveCapacity*)(this_ptr_ptr);
44848 FREE(untag_ptr(this_ptr));
44849 EffectiveCapacity_free(this_ptr_conv);
44852 static inline uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg) {
44853 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44854 *ret_copy = EffectiveCapacity_clone(arg);
44855 uint64_t ret_ref = tag_ptr(ret_copy, true);
44858 int64_t __attribute__((export_name("TS_EffectiveCapacity_clone_ptr"))) TS_EffectiveCapacity_clone_ptr(uint64_t arg) {
44859 LDKEffectiveCapacity* arg_conv = (LDKEffectiveCapacity*)untag_ptr(arg);
44860 int64_t ret_conv = EffectiveCapacity_clone_ptr(arg_conv);
44864 uint64_t __attribute__((export_name("TS_EffectiveCapacity_clone"))) TS_EffectiveCapacity_clone(uint64_t orig) {
44865 LDKEffectiveCapacity* orig_conv = (LDKEffectiveCapacity*)untag_ptr(orig);
44866 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44867 *ret_copy = EffectiveCapacity_clone(orig_conv);
44868 uint64_t ret_ref = tag_ptr(ret_copy, true);
44872 uint64_t __attribute__((export_name("TS_EffectiveCapacity_exact_liquidity"))) TS_EffectiveCapacity_exact_liquidity(int64_t liquidity_msat) {
44873 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44874 *ret_copy = EffectiveCapacity_exact_liquidity(liquidity_msat);
44875 uint64_t ret_ref = tag_ptr(ret_copy, true);
44879 uint64_t __attribute__((export_name("TS_EffectiveCapacity_maximum_htlc"))) TS_EffectiveCapacity_maximum_htlc(int64_t amount_msat) {
44880 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44881 *ret_copy = EffectiveCapacity_maximum_htlc(amount_msat);
44882 uint64_t ret_ref = tag_ptr(ret_copy, true);
44886 uint64_t __attribute__((export_name("TS_EffectiveCapacity_total"))) TS_EffectiveCapacity_total(int64_t capacity_msat, int64_t htlc_maximum_msat) {
44887 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44888 *ret_copy = EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
44889 uint64_t ret_ref = tag_ptr(ret_copy, true);
44893 uint64_t __attribute__((export_name("TS_EffectiveCapacity_infinite"))) TS_EffectiveCapacity_infinite() {
44894 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44895 *ret_copy = EffectiveCapacity_infinite();
44896 uint64_t ret_ref = tag_ptr(ret_copy, true);
44900 uint64_t __attribute__((export_name("TS_EffectiveCapacity_unknown"))) TS_EffectiveCapacity_unknown() {
44901 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44902 *ret_copy = EffectiveCapacity_unknown();
44903 uint64_t ret_ref = tag_ptr(ret_copy, true);
44907 int64_t __attribute__((export_name("TS_EffectiveCapacity_as_msat"))) TS_EffectiveCapacity_as_msat(uint64_t this_arg) {
44908 LDKEffectiveCapacity* this_arg_conv = (LDKEffectiveCapacity*)untag_ptr(this_arg);
44909 int64_t ret_conv = EffectiveCapacity_as_msat(this_arg_conv);
44913 void __attribute__((export_name("TS_RoutingFees_free"))) TS_RoutingFees_free(uint64_t this_obj) {
44914 LDKRoutingFees this_obj_conv;
44915 this_obj_conv.inner = untag_ptr(this_obj);
44916 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44917 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44918 RoutingFees_free(this_obj_conv);
44921 int32_t __attribute__((export_name("TS_RoutingFees_get_base_msat"))) TS_RoutingFees_get_base_msat(uint64_t this_ptr) {
44922 LDKRoutingFees this_ptr_conv;
44923 this_ptr_conv.inner = untag_ptr(this_ptr);
44924 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44926 this_ptr_conv.is_owned = false;
44927 int32_t ret_conv = RoutingFees_get_base_msat(&this_ptr_conv);
44931 void __attribute__((export_name("TS_RoutingFees_set_base_msat"))) TS_RoutingFees_set_base_msat(uint64_t this_ptr, int32_t val) {
44932 LDKRoutingFees this_ptr_conv;
44933 this_ptr_conv.inner = untag_ptr(this_ptr);
44934 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44936 this_ptr_conv.is_owned = false;
44937 RoutingFees_set_base_msat(&this_ptr_conv, val);
44940 int32_t __attribute__((export_name("TS_RoutingFees_get_proportional_millionths"))) TS_RoutingFees_get_proportional_millionths(uint64_t this_ptr) {
44941 LDKRoutingFees this_ptr_conv;
44942 this_ptr_conv.inner = untag_ptr(this_ptr);
44943 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44945 this_ptr_conv.is_owned = false;
44946 int32_t ret_conv = RoutingFees_get_proportional_millionths(&this_ptr_conv);
44950 void __attribute__((export_name("TS_RoutingFees_set_proportional_millionths"))) TS_RoutingFees_set_proportional_millionths(uint64_t this_ptr, int32_t val) {
44951 LDKRoutingFees this_ptr_conv;
44952 this_ptr_conv.inner = untag_ptr(this_ptr);
44953 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44954 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44955 this_ptr_conv.is_owned = false;
44956 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
44959 uint64_t __attribute__((export_name("TS_RoutingFees_new"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) {
44960 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
44961 uint64_t ret_ref = 0;
44962 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44963 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44967 jboolean __attribute__((export_name("TS_RoutingFees_eq"))) TS_RoutingFees_eq(uint64_t a, uint64_t b) {
44968 LDKRoutingFees a_conv;
44969 a_conv.inner = untag_ptr(a);
44970 a_conv.is_owned = ptr_is_owned(a);
44971 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44972 a_conv.is_owned = false;
44973 LDKRoutingFees b_conv;
44974 b_conv.inner = untag_ptr(b);
44975 b_conv.is_owned = ptr_is_owned(b);
44976 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44977 b_conv.is_owned = false;
44978 jboolean ret_conv = RoutingFees_eq(&a_conv, &b_conv);
44982 static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
44983 LDKRoutingFees ret_var = RoutingFees_clone(arg);
44984 uint64_t ret_ref = 0;
44985 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44986 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44989 int64_t __attribute__((export_name("TS_RoutingFees_clone_ptr"))) TS_RoutingFees_clone_ptr(uint64_t arg) {
44990 LDKRoutingFees arg_conv;
44991 arg_conv.inner = untag_ptr(arg);
44992 arg_conv.is_owned = ptr_is_owned(arg);
44993 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44994 arg_conv.is_owned = false;
44995 int64_t ret_conv = RoutingFees_clone_ptr(&arg_conv);
44999 uint64_t __attribute__((export_name("TS_RoutingFees_clone"))) TS_RoutingFees_clone(uint64_t orig) {
45000 LDKRoutingFees orig_conv;
45001 orig_conv.inner = untag_ptr(orig);
45002 orig_conv.is_owned = ptr_is_owned(orig);
45003 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45004 orig_conv.is_owned = false;
45005 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
45006 uint64_t ret_ref = 0;
45007 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45008 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45012 int64_t __attribute__((export_name("TS_RoutingFees_hash"))) TS_RoutingFees_hash(uint64_t o) {
45013 LDKRoutingFees o_conv;
45014 o_conv.inner = untag_ptr(o);
45015 o_conv.is_owned = ptr_is_owned(o);
45016 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
45017 o_conv.is_owned = false;
45018 int64_t ret_conv = RoutingFees_hash(&o_conv);
45022 int8_tArray __attribute__((export_name("TS_RoutingFees_write"))) TS_RoutingFees_write(uint64_t obj) {
45023 LDKRoutingFees obj_conv;
45024 obj_conv.inner = untag_ptr(obj);
45025 obj_conv.is_owned = ptr_is_owned(obj);
45026 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45027 obj_conv.is_owned = false;
45028 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
45029 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45030 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45031 CVec_u8Z_free(ret_var);
45035 uint64_t __attribute__((export_name("TS_RoutingFees_read"))) TS_RoutingFees_read(int8_tArray ser) {
45036 LDKu8slice ser_ref;
45037 ser_ref.datalen = ser->arr_len;
45038 ser_ref.data = ser->elems;
45039 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
45040 *ret_conv = RoutingFees_read(ser_ref);
45042 return tag_ptr(ret_conv, true);
45045 void __attribute__((export_name("TS_NodeAnnouncementInfo_free"))) TS_NodeAnnouncementInfo_free(uint64_t this_obj) {
45046 LDKNodeAnnouncementInfo this_obj_conv;
45047 this_obj_conv.inner = untag_ptr(this_obj);
45048 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45049 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45050 NodeAnnouncementInfo_free(this_obj_conv);
45053 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_features"))) TS_NodeAnnouncementInfo_get_features(uint64_t this_ptr) {
45054 LDKNodeAnnouncementInfo this_ptr_conv;
45055 this_ptr_conv.inner = untag_ptr(this_ptr);
45056 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45058 this_ptr_conv.is_owned = false;
45059 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
45060 uint64_t ret_ref = 0;
45061 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45062 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45066 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_features"))) TS_NodeAnnouncementInfo_set_features(uint64_t this_ptr, uint64_t val) {
45067 LDKNodeAnnouncementInfo this_ptr_conv;
45068 this_ptr_conv.inner = untag_ptr(this_ptr);
45069 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45070 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45071 this_ptr_conv.is_owned = false;
45072 LDKNodeFeatures val_conv;
45073 val_conv.inner = untag_ptr(val);
45074 val_conv.is_owned = ptr_is_owned(val);
45075 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45076 val_conv = NodeFeatures_clone(&val_conv);
45077 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
45080 int32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_last_update"))) TS_NodeAnnouncementInfo_get_last_update(uint64_t this_ptr) {
45081 LDKNodeAnnouncementInfo this_ptr_conv;
45082 this_ptr_conv.inner = untag_ptr(this_ptr);
45083 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45085 this_ptr_conv.is_owned = false;
45086 int32_t ret_conv = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
45090 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_last_update"))) TS_NodeAnnouncementInfo_set_last_update(uint64_t this_ptr, int32_t val) {
45091 LDKNodeAnnouncementInfo this_ptr_conv;
45092 this_ptr_conv.inner = untag_ptr(this_ptr);
45093 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45095 this_ptr_conv.is_owned = false;
45096 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
45099 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_get_rgb"))) TS_NodeAnnouncementInfo_get_rgb(uint64_t this_ptr) {
45100 LDKNodeAnnouncementInfo this_ptr_conv;
45101 this_ptr_conv.inner = untag_ptr(this_ptr);
45102 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45104 this_ptr_conv.is_owned = false;
45105 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
45106 memcpy(ret_arr->elems, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
45110 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_rgb"))) TS_NodeAnnouncementInfo_set_rgb(uint64_t this_ptr, int8_tArray val) {
45111 LDKNodeAnnouncementInfo this_ptr_conv;
45112 this_ptr_conv.inner = untag_ptr(this_ptr);
45113 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45114 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45115 this_ptr_conv.is_owned = false;
45116 LDKThreeBytes val_ref;
45117 CHECK(val->arr_len == 3);
45118 memcpy(val_ref.data, val->elems, 3); FREE(val);
45119 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
45122 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_alias"))) TS_NodeAnnouncementInfo_get_alias(uint64_t this_ptr) {
45123 LDKNodeAnnouncementInfo this_ptr_conv;
45124 this_ptr_conv.inner = untag_ptr(this_ptr);
45125 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45127 this_ptr_conv.is_owned = false;
45128 LDKNodeAlias ret_var = NodeAnnouncementInfo_get_alias(&this_ptr_conv);
45129 uint64_t ret_ref = 0;
45130 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45131 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45135 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_alias"))) TS_NodeAnnouncementInfo_set_alias(uint64_t this_ptr, uint64_t val) {
45136 LDKNodeAnnouncementInfo this_ptr_conv;
45137 this_ptr_conv.inner = untag_ptr(this_ptr);
45138 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45140 this_ptr_conv.is_owned = false;
45141 LDKNodeAlias val_conv;
45142 val_conv.inner = untag_ptr(val);
45143 val_conv.is_owned = ptr_is_owned(val);
45144 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45145 val_conv = NodeAlias_clone(&val_conv);
45146 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_conv);
45149 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_announcement_message"))) TS_NodeAnnouncementInfo_get_announcement_message(uint64_t this_ptr) {
45150 LDKNodeAnnouncementInfo this_ptr_conv;
45151 this_ptr_conv.inner = untag_ptr(this_ptr);
45152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45154 this_ptr_conv.is_owned = false;
45155 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
45156 uint64_t ret_ref = 0;
45157 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45158 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45162 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_announcement_message"))) TS_NodeAnnouncementInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
45163 LDKNodeAnnouncementInfo this_ptr_conv;
45164 this_ptr_conv.inner = untag_ptr(this_ptr);
45165 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45167 this_ptr_conv.is_owned = false;
45168 LDKNodeAnnouncement val_conv;
45169 val_conv.inner = untag_ptr(val);
45170 val_conv.is_owned = ptr_is_owned(val);
45171 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45172 val_conv = NodeAnnouncement_clone(&val_conv);
45173 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
45176 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_t announcement_message_arg) {
45177 LDKNodeFeatures features_arg_conv;
45178 features_arg_conv.inner = untag_ptr(features_arg);
45179 features_arg_conv.is_owned = ptr_is_owned(features_arg);
45180 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
45181 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
45182 LDKThreeBytes rgb_arg_ref;
45183 CHECK(rgb_arg->arr_len == 3);
45184 memcpy(rgb_arg_ref.data, rgb_arg->elems, 3); FREE(rgb_arg);
45185 LDKNodeAlias alias_arg_conv;
45186 alias_arg_conv.inner = untag_ptr(alias_arg);
45187 alias_arg_conv.is_owned = ptr_is_owned(alias_arg);
45188 CHECK_INNER_FIELD_ACCESS_OR_NULL(alias_arg_conv);
45189 alias_arg_conv = NodeAlias_clone(&alias_arg_conv);
45190 LDKNodeAnnouncement announcement_message_arg_conv;
45191 announcement_message_arg_conv.inner = untag_ptr(announcement_message_arg);
45192 announcement_message_arg_conv.is_owned = ptr_is_owned(announcement_message_arg);
45193 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
45194 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
45195 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_conv, announcement_message_arg_conv);
45196 uint64_t ret_ref = 0;
45197 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45198 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45202 static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
45203 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
45204 uint64_t ret_ref = 0;
45205 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45206 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45209 int64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone_ptr"))) TS_NodeAnnouncementInfo_clone_ptr(uint64_t arg) {
45210 LDKNodeAnnouncementInfo arg_conv;
45211 arg_conv.inner = untag_ptr(arg);
45212 arg_conv.is_owned = ptr_is_owned(arg);
45213 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45214 arg_conv.is_owned = false;
45215 int64_t ret_conv = NodeAnnouncementInfo_clone_ptr(&arg_conv);
45219 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone"))) TS_NodeAnnouncementInfo_clone(uint64_t orig) {
45220 LDKNodeAnnouncementInfo orig_conv;
45221 orig_conv.inner = untag_ptr(orig);
45222 orig_conv.is_owned = ptr_is_owned(orig);
45223 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45224 orig_conv.is_owned = false;
45225 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
45226 uint64_t ret_ref = 0;
45227 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45228 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45232 jboolean __attribute__((export_name("TS_NodeAnnouncementInfo_eq"))) TS_NodeAnnouncementInfo_eq(uint64_t a, uint64_t b) {
45233 LDKNodeAnnouncementInfo a_conv;
45234 a_conv.inner = untag_ptr(a);
45235 a_conv.is_owned = ptr_is_owned(a);
45236 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45237 a_conv.is_owned = false;
45238 LDKNodeAnnouncementInfo b_conv;
45239 b_conv.inner = untag_ptr(b);
45240 b_conv.is_owned = ptr_is_owned(b);
45241 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45242 b_conv.is_owned = false;
45243 jboolean ret_conv = NodeAnnouncementInfo_eq(&a_conv, &b_conv);
45247 uint64_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_addresses"))) TS_NodeAnnouncementInfo_addresses(uint64_t this_arg) {
45248 LDKNodeAnnouncementInfo this_arg_conv;
45249 this_arg_conv.inner = untag_ptr(this_arg);
45250 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45252 this_arg_conv.is_owned = false;
45253 LDKCVec_NetAddressZ ret_var = NodeAnnouncementInfo_addresses(&this_arg_conv);
45254 uint64_tArray ret_arr = NULL;
45255 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
45256 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
45257 for (size_t m = 0; m < ret_var.datalen; m++) {
45258 LDKNetAddress *ret_conv_12_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
45259 *ret_conv_12_copy = ret_var.data[m];
45260 uint64_t ret_conv_12_ref = tag_ptr(ret_conv_12_copy, true);
45261 ret_arr_ptr[m] = ret_conv_12_ref;
45264 FREE(ret_var.data);
45268 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_write"))) TS_NodeAnnouncementInfo_write(uint64_t obj) {
45269 LDKNodeAnnouncementInfo obj_conv;
45270 obj_conv.inner = untag_ptr(obj);
45271 obj_conv.is_owned = ptr_is_owned(obj);
45272 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45273 obj_conv.is_owned = false;
45274 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
45275 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45276 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45277 CVec_u8Z_free(ret_var);
45281 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_read"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) {
45282 LDKu8slice ser_ref;
45283 ser_ref.datalen = ser->arr_len;
45284 ser_ref.data = ser->elems;
45285 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
45286 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
45288 return tag_ptr(ret_conv, true);
45291 void __attribute__((export_name("TS_NodeAlias_free"))) TS_NodeAlias_free(uint64_t this_obj) {
45292 LDKNodeAlias this_obj_conv;
45293 this_obj_conv.inner = untag_ptr(this_obj);
45294 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45295 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45296 NodeAlias_free(this_obj_conv);
45299 int8_tArray __attribute__((export_name("TS_NodeAlias_get_a"))) TS_NodeAlias_get_a(uint64_t this_ptr) {
45300 LDKNodeAlias this_ptr_conv;
45301 this_ptr_conv.inner = untag_ptr(this_ptr);
45302 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45304 this_ptr_conv.is_owned = false;
45305 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
45306 memcpy(ret_arr->elems, *NodeAlias_get_a(&this_ptr_conv), 32);
45310 void __attribute__((export_name("TS_NodeAlias_set_a"))) TS_NodeAlias_set_a(uint64_t this_ptr, int8_tArray val) {
45311 LDKNodeAlias this_ptr_conv;
45312 this_ptr_conv.inner = untag_ptr(this_ptr);
45313 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45314 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45315 this_ptr_conv.is_owned = false;
45316 LDKThirtyTwoBytes val_ref;
45317 CHECK(val->arr_len == 32);
45318 memcpy(val_ref.data, val->elems, 32); FREE(val);
45319 NodeAlias_set_a(&this_ptr_conv, val_ref);
45322 uint64_t __attribute__((export_name("TS_NodeAlias_new"))) TS_NodeAlias_new(int8_tArray a_arg) {
45323 LDKThirtyTwoBytes a_arg_ref;
45324 CHECK(a_arg->arr_len == 32);
45325 memcpy(a_arg_ref.data, a_arg->elems, 32); FREE(a_arg);
45326 LDKNodeAlias ret_var = NodeAlias_new(a_arg_ref);
45327 uint64_t ret_ref = 0;
45328 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45329 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45333 static inline uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg) {
45334 LDKNodeAlias ret_var = NodeAlias_clone(arg);
45335 uint64_t ret_ref = 0;
45336 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45337 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45340 int64_t __attribute__((export_name("TS_NodeAlias_clone_ptr"))) TS_NodeAlias_clone_ptr(uint64_t arg) {
45341 LDKNodeAlias arg_conv;
45342 arg_conv.inner = untag_ptr(arg);
45343 arg_conv.is_owned = ptr_is_owned(arg);
45344 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45345 arg_conv.is_owned = false;
45346 int64_t ret_conv = NodeAlias_clone_ptr(&arg_conv);
45350 uint64_t __attribute__((export_name("TS_NodeAlias_clone"))) TS_NodeAlias_clone(uint64_t orig) {
45351 LDKNodeAlias orig_conv;
45352 orig_conv.inner = untag_ptr(orig);
45353 orig_conv.is_owned = ptr_is_owned(orig);
45354 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45355 orig_conv.is_owned = false;
45356 LDKNodeAlias ret_var = NodeAlias_clone(&orig_conv);
45357 uint64_t ret_ref = 0;
45358 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45359 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45363 jboolean __attribute__((export_name("TS_NodeAlias_eq"))) TS_NodeAlias_eq(uint64_t a, uint64_t b) {
45364 LDKNodeAlias a_conv;
45365 a_conv.inner = untag_ptr(a);
45366 a_conv.is_owned = ptr_is_owned(a);
45367 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45368 a_conv.is_owned = false;
45369 LDKNodeAlias b_conv;
45370 b_conv.inner = untag_ptr(b);
45371 b_conv.is_owned = ptr_is_owned(b);
45372 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45373 b_conv.is_owned = false;
45374 jboolean ret_conv = NodeAlias_eq(&a_conv, &b_conv);
45378 int8_tArray __attribute__((export_name("TS_NodeAlias_write"))) TS_NodeAlias_write(uint64_t obj) {
45379 LDKNodeAlias obj_conv;
45380 obj_conv.inner = untag_ptr(obj);
45381 obj_conv.is_owned = ptr_is_owned(obj);
45382 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45383 obj_conv.is_owned = false;
45384 LDKCVec_u8Z ret_var = NodeAlias_write(&obj_conv);
45385 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45386 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45387 CVec_u8Z_free(ret_var);
45391 uint64_t __attribute__((export_name("TS_NodeAlias_read"))) TS_NodeAlias_read(int8_tArray ser) {
45392 LDKu8slice ser_ref;
45393 ser_ref.datalen = ser->arr_len;
45394 ser_ref.data = ser->elems;
45395 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
45396 *ret_conv = NodeAlias_read(ser_ref);
45398 return tag_ptr(ret_conv, true);
45401 void __attribute__((export_name("TS_NodeInfo_free"))) TS_NodeInfo_free(uint64_t this_obj) {
45402 LDKNodeInfo this_obj_conv;
45403 this_obj_conv.inner = untag_ptr(this_obj);
45404 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45406 NodeInfo_free(this_obj_conv);
45409 int64_tArray __attribute__((export_name("TS_NodeInfo_get_channels"))) TS_NodeInfo_get_channels(uint64_t this_ptr) {
45410 LDKNodeInfo this_ptr_conv;
45411 this_ptr_conv.inner = untag_ptr(this_ptr);
45412 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45414 this_ptr_conv.is_owned = false;
45415 LDKCVec_u64Z ret_var = NodeInfo_get_channels(&this_ptr_conv);
45416 int64_tArray ret_arr = NULL;
45417 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
45418 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
45419 for (size_t i = 0; i < ret_var.datalen; i++) {
45420 int64_t ret_conv_8_conv = ret_var.data[i];
45421 ret_arr_ptr[i] = ret_conv_8_conv;
45424 FREE(ret_var.data);
45428 void __attribute__((export_name("TS_NodeInfo_set_channels"))) TS_NodeInfo_set_channels(uint64_t this_ptr, int64_tArray val) {
45429 LDKNodeInfo this_ptr_conv;
45430 this_ptr_conv.inner = untag_ptr(this_ptr);
45431 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45433 this_ptr_conv.is_owned = false;
45434 LDKCVec_u64Z val_constr;
45435 val_constr.datalen = val->arr_len;
45436 if (val_constr.datalen > 0)
45437 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
45439 val_constr.data = NULL;
45440 int64_t* val_vals = val->elems;
45441 for (size_t i = 0; i < val_constr.datalen; i++) {
45442 int64_t val_conv_8 = val_vals[i];
45443 val_constr.data[i] = val_conv_8;
45446 NodeInfo_set_channels(&this_ptr_conv, val_constr);
45449 uint64_t __attribute__((export_name("TS_NodeInfo_get_announcement_info"))) TS_NodeInfo_get_announcement_info(uint64_t this_ptr) {
45450 LDKNodeInfo this_ptr_conv;
45451 this_ptr_conv.inner = untag_ptr(this_ptr);
45452 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45453 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45454 this_ptr_conv.is_owned = false;
45455 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
45456 uint64_t ret_ref = 0;
45457 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45458 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45462 void __attribute__((export_name("TS_NodeInfo_set_announcement_info"))) TS_NodeInfo_set_announcement_info(uint64_t this_ptr, uint64_t val) {
45463 LDKNodeInfo this_ptr_conv;
45464 this_ptr_conv.inner = untag_ptr(this_ptr);
45465 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45467 this_ptr_conv.is_owned = false;
45468 LDKNodeAnnouncementInfo val_conv;
45469 val_conv.inner = untag_ptr(val);
45470 val_conv.is_owned = ptr_is_owned(val);
45471 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45472 val_conv = NodeAnnouncementInfo_clone(&val_conv);
45473 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
45476 uint64_t __attribute__((export_name("TS_NodeInfo_new"))) TS_NodeInfo_new(int64_tArray channels_arg, uint64_t announcement_info_arg) {
45477 LDKCVec_u64Z channels_arg_constr;
45478 channels_arg_constr.datalen = channels_arg->arr_len;
45479 if (channels_arg_constr.datalen > 0)
45480 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
45482 channels_arg_constr.data = NULL;
45483 int64_t* channels_arg_vals = channels_arg->elems;
45484 for (size_t i = 0; i < channels_arg_constr.datalen; i++) {
45485 int64_t channels_arg_conv_8 = channels_arg_vals[i];
45486 channels_arg_constr.data[i] = channels_arg_conv_8;
45488 FREE(channels_arg);
45489 LDKNodeAnnouncementInfo announcement_info_arg_conv;
45490 announcement_info_arg_conv.inner = untag_ptr(announcement_info_arg);
45491 announcement_info_arg_conv.is_owned = ptr_is_owned(announcement_info_arg);
45492 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
45493 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
45494 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, announcement_info_arg_conv);
45495 uint64_t ret_ref = 0;
45496 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45497 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45501 static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
45502 LDKNodeInfo ret_var = NodeInfo_clone(arg);
45503 uint64_t ret_ref = 0;
45504 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45505 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45508 int64_t __attribute__((export_name("TS_NodeInfo_clone_ptr"))) TS_NodeInfo_clone_ptr(uint64_t arg) {
45509 LDKNodeInfo arg_conv;
45510 arg_conv.inner = untag_ptr(arg);
45511 arg_conv.is_owned = ptr_is_owned(arg);
45512 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45513 arg_conv.is_owned = false;
45514 int64_t ret_conv = NodeInfo_clone_ptr(&arg_conv);
45518 uint64_t __attribute__((export_name("TS_NodeInfo_clone"))) TS_NodeInfo_clone(uint64_t orig) {
45519 LDKNodeInfo orig_conv;
45520 orig_conv.inner = untag_ptr(orig);
45521 orig_conv.is_owned = ptr_is_owned(orig);
45522 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45523 orig_conv.is_owned = false;
45524 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
45525 uint64_t ret_ref = 0;
45526 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45527 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45531 jboolean __attribute__((export_name("TS_NodeInfo_eq"))) TS_NodeInfo_eq(uint64_t a, uint64_t b) {
45532 LDKNodeInfo a_conv;
45533 a_conv.inner = untag_ptr(a);
45534 a_conv.is_owned = ptr_is_owned(a);
45535 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45536 a_conv.is_owned = false;
45537 LDKNodeInfo b_conv;
45538 b_conv.inner = untag_ptr(b);
45539 b_conv.is_owned = ptr_is_owned(b);
45540 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45541 b_conv.is_owned = false;
45542 jboolean ret_conv = NodeInfo_eq(&a_conv, &b_conv);
45546 int8_tArray __attribute__((export_name("TS_NodeInfo_write"))) TS_NodeInfo_write(uint64_t obj) {
45547 LDKNodeInfo obj_conv;
45548 obj_conv.inner = untag_ptr(obj);
45549 obj_conv.is_owned = ptr_is_owned(obj);
45550 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45551 obj_conv.is_owned = false;
45552 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
45553 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45554 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45555 CVec_u8Z_free(ret_var);
45559 uint64_t __attribute__((export_name("TS_NodeInfo_read"))) TS_NodeInfo_read(int8_tArray ser) {
45560 LDKu8slice ser_ref;
45561 ser_ref.datalen = ser->arr_len;
45562 ser_ref.data = ser->elems;
45563 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
45564 *ret_conv = NodeInfo_read(ser_ref);
45566 return tag_ptr(ret_conv, true);
45569 int8_tArray __attribute__((export_name("TS_NetworkGraph_write"))) TS_NetworkGraph_write(uint64_t obj) {
45570 LDKNetworkGraph obj_conv;
45571 obj_conv.inner = untag_ptr(obj);
45572 obj_conv.is_owned = ptr_is_owned(obj);
45573 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45574 obj_conv.is_owned = false;
45575 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
45576 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45577 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45578 CVec_u8Z_free(ret_var);
45582 uint64_t __attribute__((export_name("TS_NetworkGraph_read"))) TS_NetworkGraph_read(int8_tArray ser, uint64_t arg) {
45583 LDKu8slice ser_ref;
45584 ser_ref.datalen = ser->arr_len;
45585 ser_ref.data = ser->elems;
45586 void* arg_ptr = untag_ptr(arg);
45587 CHECK_ACCESS(arg_ptr);
45588 LDKLogger arg_conv = *(LDKLogger*)(arg_ptr);
45589 if (arg_conv.free == LDKLogger_JCalls_free) {
45590 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45591 LDKLogger_JCalls_cloned(&arg_conv);
45593 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
45594 *ret_conv = NetworkGraph_read(ser_ref, arg_conv);
45596 return tag_ptr(ret_conv, true);
45599 uint64_t __attribute__((export_name("TS_NetworkGraph_new"))) TS_NetworkGraph_new(uint32_t network, uint64_t logger) {
45600 LDKNetwork network_conv = LDKNetwork_from_js(network);
45601 void* logger_ptr = untag_ptr(logger);
45602 CHECK_ACCESS(logger_ptr);
45603 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45604 if (logger_conv.free == LDKLogger_JCalls_free) {
45605 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45606 LDKLogger_JCalls_cloned(&logger_conv);
45608 LDKNetworkGraph ret_var = NetworkGraph_new(network_conv, logger_conv);
45609 uint64_t ret_ref = 0;
45610 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45611 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45615 uint64_t __attribute__((export_name("TS_NetworkGraph_read_only"))) TS_NetworkGraph_read_only(uint64_t this_arg) {
45616 LDKNetworkGraph this_arg_conv;
45617 this_arg_conv.inner = untag_ptr(this_arg);
45618 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45620 this_arg_conv.is_owned = false;
45621 LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
45622 uint64_t ret_ref = 0;
45623 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45624 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45628 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) {
45629 LDKNetworkGraph this_arg_conv;
45630 this_arg_conv.inner = untag_ptr(this_arg);
45631 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45632 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45633 this_arg_conv.is_owned = false;
45634 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
45635 *ret_copy = NetworkGraph_get_last_rapid_gossip_sync_timestamp(&this_arg_conv);
45636 uint64_t ret_ref = tag_ptr(ret_copy, true);
45640 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) {
45641 LDKNetworkGraph this_arg_conv;
45642 this_arg_conv.inner = untag_ptr(this_arg);
45643 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45645 this_arg_conv.is_owned = false;
45646 NetworkGraph_set_last_rapid_gossip_sync_timestamp(&this_arg_conv, last_rapid_gossip_sync_timestamp);
45649 uint64_t __attribute__((export_name("TS_NetworkGraph_update_node_from_announcement"))) TS_NetworkGraph_update_node_from_announcement(uint64_t this_arg, uint64_t msg) {
45650 LDKNetworkGraph this_arg_conv;
45651 this_arg_conv.inner = untag_ptr(this_arg);
45652 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45654 this_arg_conv.is_owned = false;
45655 LDKNodeAnnouncement msg_conv;
45656 msg_conv.inner = untag_ptr(msg);
45657 msg_conv.is_owned = ptr_is_owned(msg);
45658 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45659 msg_conv.is_owned = false;
45660 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45661 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
45662 return tag_ptr(ret_conv, true);
45665 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) {
45666 LDKNetworkGraph this_arg_conv;
45667 this_arg_conv.inner = untag_ptr(this_arg);
45668 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45670 this_arg_conv.is_owned = false;
45671 LDKUnsignedNodeAnnouncement msg_conv;
45672 msg_conv.inner = untag_ptr(msg);
45673 msg_conv.is_owned = ptr_is_owned(msg);
45674 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45675 msg_conv.is_owned = false;
45676 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45677 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
45678 return tag_ptr(ret_conv, true);
45681 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 utxo_lookup) {
45682 LDKNetworkGraph this_arg_conv;
45683 this_arg_conv.inner = untag_ptr(this_arg);
45684 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45686 this_arg_conv.is_owned = false;
45687 LDKChannelAnnouncement msg_conv;
45688 msg_conv.inner = untag_ptr(msg);
45689 msg_conv.is_owned = ptr_is_owned(msg);
45690 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45691 msg_conv.is_owned = false;
45692 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
45693 CHECK_ACCESS(utxo_lookup_ptr);
45694 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
45695 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
45696 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
45697 // Manually implement clone for Java trait instances
45698 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
45699 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45700 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
45703 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45704 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, utxo_lookup_conv);
45705 return tag_ptr(ret_conv, true);
45708 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 utxo_lookup) {
45709 LDKNetworkGraph this_arg_conv;
45710 this_arg_conv.inner = untag_ptr(this_arg);
45711 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45712 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45713 this_arg_conv.is_owned = false;
45714 LDKUnsignedChannelAnnouncement msg_conv;
45715 msg_conv.inner = untag_ptr(msg);
45716 msg_conv.is_owned = ptr_is_owned(msg);
45717 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45718 msg_conv.is_owned = false;
45719 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
45720 CHECK_ACCESS(utxo_lookup_ptr);
45721 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
45722 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
45723 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
45724 // Manually implement clone for Java trait instances
45725 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
45726 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45727 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
45730 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45731 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, utxo_lookup_conv);
45732 return tag_ptr(ret_conv, true);
45735 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) {
45736 LDKNetworkGraph this_arg_conv;
45737 this_arg_conv.inner = untag_ptr(this_arg);
45738 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45740 this_arg_conv.is_owned = false;
45741 LDKChannelFeatures features_conv;
45742 features_conv.inner = untag_ptr(features);
45743 features_conv.is_owned = ptr_is_owned(features);
45744 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
45745 features_conv = ChannelFeatures_clone(&features_conv);
45746 LDKPublicKey node_id_1_ref;
45747 CHECK(node_id_1->arr_len == 33);
45748 memcpy(node_id_1_ref.compressed_form, node_id_1->elems, 33); FREE(node_id_1);
45749 LDKPublicKey node_id_2_ref;
45750 CHECK(node_id_2->arr_len == 33);
45751 memcpy(node_id_2_ref.compressed_form, node_id_2->elems, 33); FREE(node_id_2);
45752 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45753 *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);
45754 return tag_ptr(ret_conv, true);
45757 void __attribute__((export_name("TS_NetworkGraph_channel_failed_permanent"))) TS_NetworkGraph_channel_failed_permanent(uint64_t this_arg, int64_t short_channel_id) {
45758 LDKNetworkGraph this_arg_conv;
45759 this_arg_conv.inner = untag_ptr(this_arg);
45760 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45762 this_arg_conv.is_owned = false;
45763 NetworkGraph_channel_failed_permanent(&this_arg_conv, short_channel_id);
45766 void __attribute__((export_name("TS_NetworkGraph_node_failed_permanent"))) TS_NetworkGraph_node_failed_permanent(uint64_t this_arg, int8_tArray node_id) {
45767 LDKNetworkGraph this_arg_conv;
45768 this_arg_conv.inner = untag_ptr(this_arg);
45769 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45771 this_arg_conv.is_owned = false;
45772 LDKPublicKey node_id_ref;
45773 CHECK(node_id->arr_len == 33);
45774 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
45775 NetworkGraph_node_failed_permanent(&this_arg_conv, node_id_ref);
45778 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) {
45779 LDKNetworkGraph 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 NetworkGraph_remove_stale_channels_and_tracking_with_time(&this_arg_conv, current_time_unix);
45787 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel"))) TS_NetworkGraph_update_channel(uint64_t this_arg, uint64_t msg) {
45788 LDKNetworkGraph 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 LDKChannelUpdate msg_conv;
45794 msg_conv.inner = untag_ptr(msg);
45795 msg_conv.is_owned = ptr_is_owned(msg);
45796 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45797 msg_conv.is_owned = false;
45798 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45799 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
45800 return tag_ptr(ret_conv, true);
45803 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_unsigned"))) TS_NetworkGraph_update_channel_unsigned(uint64_t this_arg, uint64_t msg) {
45804 LDKNetworkGraph this_arg_conv;
45805 this_arg_conv.inner = untag_ptr(this_arg);
45806 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45808 this_arg_conv.is_owned = false;
45809 LDKUnsignedChannelUpdate msg_conv;
45810 msg_conv.inner = untag_ptr(msg);
45811 msg_conv.is_owned = ptr_is_owned(msg);
45812 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45813 msg_conv.is_owned = false;
45814 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45815 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
45816 return tag_ptr(ret_conv, true);
45819 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_channel"))) TS_ReadOnlyNetworkGraph_channel(uint64_t this_arg, int64_t short_channel_id) {
45820 LDKReadOnlyNetworkGraph this_arg_conv;
45821 this_arg_conv.inner = untag_ptr(this_arg);
45822 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45824 this_arg_conv.is_owned = false;
45825 LDKChannelInfo ret_var = ReadOnlyNetworkGraph_channel(&this_arg_conv, short_channel_id);
45826 uint64_t ret_ref = 0;
45827 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45828 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45832 int64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_channels"))) TS_ReadOnlyNetworkGraph_list_channels(uint64_t this_arg) {
45833 LDKReadOnlyNetworkGraph 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 LDKCVec_u64Z ret_var = ReadOnlyNetworkGraph_list_channels(&this_arg_conv);
45839 int64_tArray ret_arr = NULL;
45840 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
45841 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
45842 for (size_t i = 0; i < ret_var.datalen; i++) {
45843 int64_t ret_conv_8_conv = ret_var.data[i];
45844 ret_arr_ptr[i] = ret_conv_8_conv;
45847 FREE(ret_var.data);
45851 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_node"))) TS_ReadOnlyNetworkGraph_node(uint64_t this_arg, uint64_t node_id) {
45852 LDKReadOnlyNetworkGraph this_arg_conv;
45853 this_arg_conv.inner = untag_ptr(this_arg);
45854 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45856 this_arg_conv.is_owned = false;
45857 LDKNodeId node_id_conv;
45858 node_id_conv.inner = untag_ptr(node_id);
45859 node_id_conv.is_owned = ptr_is_owned(node_id);
45860 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
45861 node_id_conv.is_owned = false;
45862 LDKNodeInfo ret_var = ReadOnlyNetworkGraph_node(&this_arg_conv, &node_id_conv);
45863 uint64_t ret_ref = 0;
45864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45865 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45869 uint64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_nodes"))) TS_ReadOnlyNetworkGraph_list_nodes(uint64_t this_arg) {
45870 LDKReadOnlyNetworkGraph 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 ret_var = ReadOnlyNetworkGraph_list_nodes(&this_arg_conv);
45876 uint64_tArray ret_arr = NULL;
45877 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
45878 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
45879 for (size_t i = 0; i < ret_var.datalen; i++) {
45880 LDKNodeId ret_conv_8_var = ret_var.data[i];
45881 uint64_t ret_conv_8_ref = 0;
45882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_8_var);
45883 ret_conv_8_ref = tag_ptr(ret_conv_8_var.inner, ret_conv_8_var.is_owned);
45884 ret_arr_ptr[i] = ret_conv_8_ref;
45887 FREE(ret_var.data);
45891 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_get_addresses"))) TS_ReadOnlyNetworkGraph_get_addresses(uint64_t this_arg, int8_tArray pubkey) {
45892 LDKReadOnlyNetworkGraph this_arg_conv;
45893 this_arg_conv.inner = untag_ptr(this_arg);
45894 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45896 this_arg_conv.is_owned = false;
45897 LDKPublicKey pubkey_ref;
45898 CHECK(pubkey->arr_len == 33);
45899 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
45900 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
45901 *ret_copy = ReadOnlyNetworkGraph_get_addresses(&this_arg_conv, pubkey_ref);
45902 uint64_t ret_ref = tag_ptr(ret_copy, true);
45906 void __attribute__((export_name("TS_DefaultRouter_free"))) TS_DefaultRouter_free(uint64_t this_obj) {
45907 LDKDefaultRouter this_obj_conv;
45908 this_obj_conv.inner = untag_ptr(this_obj);
45909 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45911 DefaultRouter_free(this_obj_conv);
45914 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) {
45915 LDKNetworkGraph network_graph_conv;
45916 network_graph_conv.inner = untag_ptr(network_graph);
45917 network_graph_conv.is_owned = ptr_is_owned(network_graph);
45918 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
45919 network_graph_conv.is_owned = false;
45920 void* logger_ptr = untag_ptr(logger);
45921 CHECK_ACCESS(logger_ptr);
45922 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45923 if (logger_conv.free == LDKLogger_JCalls_free) {
45924 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45925 LDKLogger_JCalls_cloned(&logger_conv);
45927 LDKThirtyTwoBytes random_seed_bytes_ref;
45928 CHECK(random_seed_bytes->arr_len == 32);
45929 memcpy(random_seed_bytes_ref.data, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
45930 void* scorer_ptr = untag_ptr(scorer);
45931 CHECK_ACCESS(scorer_ptr);
45932 LDKLockableScore scorer_conv = *(LDKLockableScore*)(scorer_ptr);
45933 if (scorer_conv.free == LDKLockableScore_JCalls_free) {
45934 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45935 LDKLockableScore_JCalls_cloned(&scorer_conv);
45937 LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref, scorer_conv);
45938 uint64_t ret_ref = 0;
45939 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45940 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45944 uint64_t __attribute__((export_name("TS_DefaultRouter_as_Router"))) TS_DefaultRouter_as_Router(uint64_t this_arg) {
45945 LDKDefaultRouter this_arg_conv;
45946 this_arg_conv.inner = untag_ptr(this_arg);
45947 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45948 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45949 this_arg_conv.is_owned = false;
45950 LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
45951 *ret_ret = DefaultRouter_as_Router(&this_arg_conv);
45952 return tag_ptr(ret_ret, true);
45955 void __attribute__((export_name("TS_Router_free"))) TS_Router_free(uint64_t this_ptr) {
45956 if (!ptr_is_owned(this_ptr)) return;
45957 void* this_ptr_ptr = untag_ptr(this_ptr);
45958 CHECK_ACCESS(this_ptr_ptr);
45959 LDKRouter this_ptr_conv = *(LDKRouter*)(this_ptr_ptr);
45960 FREE(untag_ptr(this_ptr));
45961 Router_free(this_ptr_conv);
45964 void __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_free"))) TS_ScorerAccountingForInFlightHtlcs_free(uint64_t this_obj) {
45965 LDKScorerAccountingForInFlightHtlcs this_obj_conv;
45966 this_obj_conv.inner = untag_ptr(this_obj);
45967 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45969 ScorerAccountingForInFlightHtlcs_free(this_obj_conv);
45972 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_new"))) TS_ScorerAccountingForInFlightHtlcs_new(uint64_t scorer, uint64_t inflight_htlcs) {
45973 void* scorer_ptr = untag_ptr(scorer);
45974 CHECK_ACCESS(scorer_ptr);
45975 LDKScore scorer_conv = *(LDKScore*)(scorer_ptr);
45976 if (scorer_conv.free == LDKScore_JCalls_free) {
45977 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45978 LDKScore_JCalls_cloned(&scorer_conv);
45980 LDKInFlightHtlcs inflight_htlcs_conv;
45981 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
45982 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
45983 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
45984 inflight_htlcs_conv.is_owned = false;
45985 LDKScorerAccountingForInFlightHtlcs ret_var = ScorerAccountingForInFlightHtlcs_new(scorer_conv, &inflight_htlcs_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 int8_tArray __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_write"))) TS_ScorerAccountingForInFlightHtlcs_write(uint64_t obj) {
45993 LDKScorerAccountingForInFlightHtlcs obj_conv;
45994 obj_conv.inner = untag_ptr(obj);
45995 obj_conv.is_owned = ptr_is_owned(obj);
45996 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45997 obj_conv.is_owned = false;
45998 LDKCVec_u8Z ret_var = ScorerAccountingForInFlightHtlcs_write(&obj_conv);
45999 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46000 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46001 CVec_u8Z_free(ret_var);
46005 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_as_Score"))) TS_ScorerAccountingForInFlightHtlcs_as_Score(uint64_t this_arg) {
46006 LDKScorerAccountingForInFlightHtlcs this_arg_conv;
46007 this_arg_conv.inner = untag_ptr(this_arg);
46008 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46009 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46010 this_arg_conv.is_owned = false;
46011 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
46012 *ret_ret = ScorerAccountingForInFlightHtlcs_as_Score(&this_arg_conv);
46013 return tag_ptr(ret_ret, true);
46016 void __attribute__((export_name("TS_InFlightHtlcs_free"))) TS_InFlightHtlcs_free(uint64_t this_obj) {
46017 LDKInFlightHtlcs this_obj_conv;
46018 this_obj_conv.inner = untag_ptr(this_obj);
46019 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46021 InFlightHtlcs_free(this_obj_conv);
46024 static inline uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg) {
46025 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(arg);
46026 uint64_t ret_ref = 0;
46027 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46028 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46031 int64_t __attribute__((export_name("TS_InFlightHtlcs_clone_ptr"))) TS_InFlightHtlcs_clone_ptr(uint64_t arg) {
46032 LDKInFlightHtlcs arg_conv;
46033 arg_conv.inner = untag_ptr(arg);
46034 arg_conv.is_owned = ptr_is_owned(arg);
46035 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46036 arg_conv.is_owned = false;
46037 int64_t ret_conv = InFlightHtlcs_clone_ptr(&arg_conv);
46041 uint64_t __attribute__((export_name("TS_InFlightHtlcs_clone"))) TS_InFlightHtlcs_clone(uint64_t orig) {
46042 LDKInFlightHtlcs orig_conv;
46043 orig_conv.inner = untag_ptr(orig);
46044 orig_conv.is_owned = ptr_is_owned(orig);
46045 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46046 orig_conv.is_owned = false;
46047 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(&orig_conv);
46048 uint64_t ret_ref = 0;
46049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46054 uint64_t __attribute__((export_name("TS_InFlightHtlcs_new"))) TS_InFlightHtlcs_new() {
46055 LDKInFlightHtlcs ret_var = InFlightHtlcs_new();
46056 uint64_t ret_ref = 0;
46057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46062 void __attribute__((export_name("TS_InFlightHtlcs_process_path"))) TS_InFlightHtlcs_process_path(uint64_t this_arg, uint64_t path, int8_tArray payer_node_id) {
46063 LDKInFlightHtlcs this_arg_conv;
46064 this_arg_conv.inner = untag_ptr(this_arg);
46065 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46067 this_arg_conv.is_owned = false;
46069 path_conv.inner = untag_ptr(path);
46070 path_conv.is_owned = ptr_is_owned(path);
46071 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
46072 path_conv.is_owned = false;
46073 LDKPublicKey payer_node_id_ref;
46074 CHECK(payer_node_id->arr_len == 33);
46075 memcpy(payer_node_id_ref.compressed_form, payer_node_id->elems, 33); FREE(payer_node_id);
46076 InFlightHtlcs_process_path(&this_arg_conv, &path_conv, payer_node_id_ref);
46079 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) {
46080 LDKInFlightHtlcs this_arg_conv;
46081 this_arg_conv.inner = untag_ptr(this_arg);
46082 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46083 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46084 this_arg_conv.is_owned = false;
46085 LDKNodeId source_conv;
46086 source_conv.inner = untag_ptr(source);
46087 source_conv.is_owned = ptr_is_owned(source);
46088 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
46089 source_conv.is_owned = false;
46090 LDKNodeId target_conv;
46091 target_conv.inner = untag_ptr(target);
46092 target_conv.is_owned = ptr_is_owned(target);
46093 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
46094 target_conv.is_owned = false;
46095 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
46096 *ret_copy = InFlightHtlcs_used_liquidity_msat(&this_arg_conv, &source_conv, &target_conv, channel_scid);
46097 uint64_t ret_ref = tag_ptr(ret_copy, true);
46101 int8_tArray __attribute__((export_name("TS_InFlightHtlcs_write"))) TS_InFlightHtlcs_write(uint64_t obj) {
46102 LDKInFlightHtlcs obj_conv;
46103 obj_conv.inner = untag_ptr(obj);
46104 obj_conv.is_owned = ptr_is_owned(obj);
46105 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46106 obj_conv.is_owned = false;
46107 LDKCVec_u8Z ret_var = InFlightHtlcs_write(&obj_conv);
46108 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46109 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46110 CVec_u8Z_free(ret_var);
46114 uint64_t __attribute__((export_name("TS_InFlightHtlcs_read"))) TS_InFlightHtlcs_read(int8_tArray ser) {
46115 LDKu8slice ser_ref;
46116 ser_ref.datalen = ser->arr_len;
46117 ser_ref.data = ser->elems;
46118 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
46119 *ret_conv = InFlightHtlcs_read(ser_ref);
46121 return tag_ptr(ret_conv, true);
46124 void __attribute__((export_name("TS_RouteHop_free"))) TS_RouteHop_free(uint64_t this_obj) {
46125 LDKRouteHop this_obj_conv;
46126 this_obj_conv.inner = untag_ptr(this_obj);
46127 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46129 RouteHop_free(this_obj_conv);
46132 int8_tArray __attribute__((export_name("TS_RouteHop_get_pubkey"))) TS_RouteHop_get_pubkey(uint64_t this_ptr) {
46133 LDKRouteHop this_ptr_conv;
46134 this_ptr_conv.inner = untag_ptr(this_ptr);
46135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46137 this_ptr_conv.is_owned = false;
46138 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46139 memcpy(ret_arr->elems, RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
46143 void __attribute__((export_name("TS_RouteHop_set_pubkey"))) TS_RouteHop_set_pubkey(uint64_t this_ptr, int8_tArray val) {
46144 LDKRouteHop this_ptr_conv;
46145 this_ptr_conv.inner = untag_ptr(this_ptr);
46146 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46147 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46148 this_ptr_conv.is_owned = false;
46149 LDKPublicKey val_ref;
46150 CHECK(val->arr_len == 33);
46151 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46152 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
46155 uint64_t __attribute__((export_name("TS_RouteHop_get_node_features"))) TS_RouteHop_get_node_features(uint64_t this_ptr) {
46156 LDKRouteHop this_ptr_conv;
46157 this_ptr_conv.inner = untag_ptr(this_ptr);
46158 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46160 this_ptr_conv.is_owned = false;
46161 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
46162 uint64_t ret_ref = 0;
46163 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46164 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46168 void __attribute__((export_name("TS_RouteHop_set_node_features"))) TS_RouteHop_set_node_features(uint64_t this_ptr, uint64_t val) {
46169 LDKRouteHop this_ptr_conv;
46170 this_ptr_conv.inner = untag_ptr(this_ptr);
46171 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46172 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46173 this_ptr_conv.is_owned = false;
46174 LDKNodeFeatures val_conv;
46175 val_conv.inner = untag_ptr(val);
46176 val_conv.is_owned = ptr_is_owned(val);
46177 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46178 val_conv = NodeFeatures_clone(&val_conv);
46179 RouteHop_set_node_features(&this_ptr_conv, val_conv);
46182 int64_t __attribute__((export_name("TS_RouteHop_get_short_channel_id"))) TS_RouteHop_get_short_channel_id(uint64_t this_ptr) {
46183 LDKRouteHop this_ptr_conv;
46184 this_ptr_conv.inner = untag_ptr(this_ptr);
46185 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46187 this_ptr_conv.is_owned = false;
46188 int64_t ret_conv = RouteHop_get_short_channel_id(&this_ptr_conv);
46192 void __attribute__((export_name("TS_RouteHop_set_short_channel_id"))) TS_RouteHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
46193 LDKRouteHop this_ptr_conv;
46194 this_ptr_conv.inner = untag_ptr(this_ptr);
46195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46197 this_ptr_conv.is_owned = false;
46198 RouteHop_set_short_channel_id(&this_ptr_conv, val);
46201 uint64_t __attribute__((export_name("TS_RouteHop_get_channel_features"))) TS_RouteHop_get_channel_features(uint64_t this_ptr) {
46202 LDKRouteHop this_ptr_conv;
46203 this_ptr_conv.inner = untag_ptr(this_ptr);
46204 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46206 this_ptr_conv.is_owned = false;
46207 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
46208 uint64_t ret_ref = 0;
46209 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46210 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46214 void __attribute__((export_name("TS_RouteHop_set_channel_features"))) TS_RouteHop_set_channel_features(uint64_t this_ptr, uint64_t val) {
46215 LDKRouteHop this_ptr_conv;
46216 this_ptr_conv.inner = untag_ptr(this_ptr);
46217 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46218 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46219 this_ptr_conv.is_owned = false;
46220 LDKChannelFeatures val_conv;
46221 val_conv.inner = untag_ptr(val);
46222 val_conv.is_owned = ptr_is_owned(val);
46223 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46224 val_conv = ChannelFeatures_clone(&val_conv);
46225 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
46228 int64_t __attribute__((export_name("TS_RouteHop_get_fee_msat"))) TS_RouteHop_get_fee_msat(uint64_t this_ptr) {
46229 LDKRouteHop this_ptr_conv;
46230 this_ptr_conv.inner = untag_ptr(this_ptr);
46231 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46233 this_ptr_conv.is_owned = false;
46234 int64_t ret_conv = RouteHop_get_fee_msat(&this_ptr_conv);
46238 void __attribute__((export_name("TS_RouteHop_set_fee_msat"))) TS_RouteHop_set_fee_msat(uint64_t this_ptr, int64_t val) {
46239 LDKRouteHop this_ptr_conv;
46240 this_ptr_conv.inner = untag_ptr(this_ptr);
46241 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46243 this_ptr_conv.is_owned = false;
46244 RouteHop_set_fee_msat(&this_ptr_conv, val);
46247 int32_t __attribute__((export_name("TS_RouteHop_get_cltv_expiry_delta"))) TS_RouteHop_get_cltv_expiry_delta(uint64_t this_ptr) {
46248 LDKRouteHop this_ptr_conv;
46249 this_ptr_conv.inner = untag_ptr(this_ptr);
46250 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46252 this_ptr_conv.is_owned = false;
46253 int32_t ret_conv = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
46257 void __attribute__((export_name("TS_RouteHop_set_cltv_expiry_delta"))) TS_RouteHop_set_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
46258 LDKRouteHop this_ptr_conv;
46259 this_ptr_conv.inner = untag_ptr(this_ptr);
46260 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46262 this_ptr_conv.is_owned = false;
46263 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
46266 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) {
46267 LDKPublicKey pubkey_arg_ref;
46268 CHECK(pubkey_arg->arr_len == 33);
46269 memcpy(pubkey_arg_ref.compressed_form, pubkey_arg->elems, 33); FREE(pubkey_arg);
46270 LDKNodeFeatures node_features_arg_conv;
46271 node_features_arg_conv.inner = untag_ptr(node_features_arg);
46272 node_features_arg_conv.is_owned = ptr_is_owned(node_features_arg);
46273 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
46274 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
46275 LDKChannelFeatures channel_features_arg_conv;
46276 channel_features_arg_conv.inner = untag_ptr(channel_features_arg);
46277 channel_features_arg_conv.is_owned = ptr_is_owned(channel_features_arg);
46278 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
46279 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
46280 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);
46281 uint64_t ret_ref = 0;
46282 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46283 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46287 static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
46288 LDKRouteHop ret_var = RouteHop_clone(arg);
46289 uint64_t ret_ref = 0;
46290 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46291 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46294 int64_t __attribute__((export_name("TS_RouteHop_clone_ptr"))) TS_RouteHop_clone_ptr(uint64_t arg) {
46295 LDKRouteHop arg_conv;
46296 arg_conv.inner = untag_ptr(arg);
46297 arg_conv.is_owned = ptr_is_owned(arg);
46298 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46299 arg_conv.is_owned = false;
46300 int64_t ret_conv = RouteHop_clone_ptr(&arg_conv);
46304 uint64_t __attribute__((export_name("TS_RouteHop_clone"))) TS_RouteHop_clone(uint64_t orig) {
46305 LDKRouteHop orig_conv;
46306 orig_conv.inner = untag_ptr(orig);
46307 orig_conv.is_owned = ptr_is_owned(orig);
46308 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46309 orig_conv.is_owned = false;
46310 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
46311 uint64_t ret_ref = 0;
46312 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46313 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46317 int64_t __attribute__((export_name("TS_RouteHop_hash"))) TS_RouteHop_hash(uint64_t o) {
46318 LDKRouteHop o_conv;
46319 o_conv.inner = untag_ptr(o);
46320 o_conv.is_owned = ptr_is_owned(o);
46321 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46322 o_conv.is_owned = false;
46323 int64_t ret_conv = RouteHop_hash(&o_conv);
46327 jboolean __attribute__((export_name("TS_RouteHop_eq"))) TS_RouteHop_eq(uint64_t a, uint64_t b) {
46328 LDKRouteHop a_conv;
46329 a_conv.inner = untag_ptr(a);
46330 a_conv.is_owned = ptr_is_owned(a);
46331 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46332 a_conv.is_owned = false;
46333 LDKRouteHop b_conv;
46334 b_conv.inner = untag_ptr(b);
46335 b_conv.is_owned = ptr_is_owned(b);
46336 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46337 b_conv.is_owned = false;
46338 jboolean ret_conv = RouteHop_eq(&a_conv, &b_conv);
46342 int8_tArray __attribute__((export_name("TS_RouteHop_write"))) TS_RouteHop_write(uint64_t obj) {
46343 LDKRouteHop obj_conv;
46344 obj_conv.inner = untag_ptr(obj);
46345 obj_conv.is_owned = ptr_is_owned(obj);
46346 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46347 obj_conv.is_owned = false;
46348 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
46349 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46350 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46351 CVec_u8Z_free(ret_var);
46355 uint64_t __attribute__((export_name("TS_RouteHop_read"))) TS_RouteHop_read(int8_tArray ser) {
46356 LDKu8slice ser_ref;
46357 ser_ref.datalen = ser->arr_len;
46358 ser_ref.data = ser->elems;
46359 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
46360 *ret_conv = RouteHop_read(ser_ref);
46362 return tag_ptr(ret_conv, true);
46365 void __attribute__((export_name("TS_BlindedTail_free"))) TS_BlindedTail_free(uint64_t this_obj) {
46366 LDKBlindedTail this_obj_conv;
46367 this_obj_conv.inner = untag_ptr(this_obj);
46368 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46369 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46370 BlindedTail_free(this_obj_conv);
46373 uint64_tArray __attribute__((export_name("TS_BlindedTail_get_hops"))) TS_BlindedTail_get_hops(uint64_t this_ptr) {
46374 LDKBlindedTail this_ptr_conv;
46375 this_ptr_conv.inner = untag_ptr(this_ptr);
46376 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46377 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46378 this_ptr_conv.is_owned = false;
46379 LDKCVec_BlindedHopZ ret_var = BlindedTail_get_hops(&this_ptr_conv);
46380 uint64_tArray ret_arr = NULL;
46381 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46382 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46383 for (size_t m = 0; m < ret_var.datalen; m++) {
46384 LDKBlindedHop ret_conv_12_var = ret_var.data[m];
46385 uint64_t ret_conv_12_ref = 0;
46386 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_var);
46387 ret_conv_12_ref = tag_ptr(ret_conv_12_var.inner, ret_conv_12_var.is_owned);
46388 ret_arr_ptr[m] = ret_conv_12_ref;
46391 FREE(ret_var.data);
46395 void __attribute__((export_name("TS_BlindedTail_set_hops"))) TS_BlindedTail_set_hops(uint64_t this_ptr, uint64_tArray val) {
46396 LDKBlindedTail this_ptr_conv;
46397 this_ptr_conv.inner = untag_ptr(this_ptr);
46398 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46400 this_ptr_conv.is_owned = false;
46401 LDKCVec_BlindedHopZ val_constr;
46402 val_constr.datalen = val->arr_len;
46403 if (val_constr.datalen > 0)
46404 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
46406 val_constr.data = NULL;
46407 uint64_t* val_vals = val->elems;
46408 for (size_t m = 0; m < val_constr.datalen; m++) {
46409 uint64_t val_conv_12 = val_vals[m];
46410 LDKBlindedHop val_conv_12_conv;
46411 val_conv_12_conv.inner = untag_ptr(val_conv_12);
46412 val_conv_12_conv.is_owned = ptr_is_owned(val_conv_12);
46413 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv);
46414 val_conv_12_conv = BlindedHop_clone(&val_conv_12_conv);
46415 val_constr.data[m] = val_conv_12_conv;
46418 BlindedTail_set_hops(&this_ptr_conv, val_constr);
46421 int8_tArray __attribute__((export_name("TS_BlindedTail_get_blinding_point"))) TS_BlindedTail_get_blinding_point(uint64_t this_ptr) {
46422 LDKBlindedTail this_ptr_conv;
46423 this_ptr_conv.inner = untag_ptr(this_ptr);
46424 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46425 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46426 this_ptr_conv.is_owned = false;
46427 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46428 memcpy(ret_arr->elems, BlindedTail_get_blinding_point(&this_ptr_conv).compressed_form, 33);
46432 void __attribute__((export_name("TS_BlindedTail_set_blinding_point"))) TS_BlindedTail_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
46433 LDKBlindedTail this_ptr_conv;
46434 this_ptr_conv.inner = untag_ptr(this_ptr);
46435 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46436 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46437 this_ptr_conv.is_owned = false;
46438 LDKPublicKey val_ref;
46439 CHECK(val->arr_len == 33);
46440 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46441 BlindedTail_set_blinding_point(&this_ptr_conv, val_ref);
46444 int32_t __attribute__((export_name("TS_BlindedTail_get_excess_final_cltv_expiry_delta"))) TS_BlindedTail_get_excess_final_cltv_expiry_delta(uint64_t this_ptr) {
46445 LDKBlindedTail this_ptr_conv;
46446 this_ptr_conv.inner = untag_ptr(this_ptr);
46447 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46448 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46449 this_ptr_conv.is_owned = false;
46450 int32_t ret_conv = BlindedTail_get_excess_final_cltv_expiry_delta(&this_ptr_conv);
46454 void __attribute__((export_name("TS_BlindedTail_set_excess_final_cltv_expiry_delta"))) TS_BlindedTail_set_excess_final_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
46455 LDKBlindedTail this_ptr_conv;
46456 this_ptr_conv.inner = untag_ptr(this_ptr);
46457 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46459 this_ptr_conv.is_owned = false;
46460 BlindedTail_set_excess_final_cltv_expiry_delta(&this_ptr_conv, val);
46463 int64_t __attribute__((export_name("TS_BlindedTail_get_final_value_msat"))) TS_BlindedTail_get_final_value_msat(uint64_t this_ptr) {
46464 LDKBlindedTail this_ptr_conv;
46465 this_ptr_conv.inner = untag_ptr(this_ptr);
46466 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46468 this_ptr_conv.is_owned = false;
46469 int64_t ret_conv = BlindedTail_get_final_value_msat(&this_ptr_conv);
46473 void __attribute__((export_name("TS_BlindedTail_set_final_value_msat"))) TS_BlindedTail_set_final_value_msat(uint64_t this_ptr, int64_t val) {
46474 LDKBlindedTail this_ptr_conv;
46475 this_ptr_conv.inner = untag_ptr(this_ptr);
46476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46478 this_ptr_conv.is_owned = false;
46479 BlindedTail_set_final_value_msat(&this_ptr_conv, val);
46482 uint64_t __attribute__((export_name("TS_BlindedTail_new"))) TS_BlindedTail_new(uint64_tArray hops_arg, int8_tArray blinding_point_arg, int32_t excess_final_cltv_expiry_delta_arg, int64_t final_value_msat_arg) {
46483 LDKCVec_BlindedHopZ hops_arg_constr;
46484 hops_arg_constr.datalen = hops_arg->arr_len;
46485 if (hops_arg_constr.datalen > 0)
46486 hops_arg_constr.data = MALLOC(hops_arg_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
46488 hops_arg_constr.data = NULL;
46489 uint64_t* hops_arg_vals = hops_arg->elems;
46490 for (size_t m = 0; m < hops_arg_constr.datalen; m++) {
46491 uint64_t hops_arg_conv_12 = hops_arg_vals[m];
46492 LDKBlindedHop hops_arg_conv_12_conv;
46493 hops_arg_conv_12_conv.inner = untag_ptr(hops_arg_conv_12);
46494 hops_arg_conv_12_conv.is_owned = ptr_is_owned(hops_arg_conv_12);
46495 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_arg_conv_12_conv);
46496 hops_arg_conv_12_conv = BlindedHop_clone(&hops_arg_conv_12_conv);
46497 hops_arg_constr.data[m] = hops_arg_conv_12_conv;
46500 LDKPublicKey blinding_point_arg_ref;
46501 CHECK(blinding_point_arg->arr_len == 33);
46502 memcpy(blinding_point_arg_ref.compressed_form, blinding_point_arg->elems, 33); FREE(blinding_point_arg);
46503 LDKBlindedTail ret_var = BlindedTail_new(hops_arg_constr, blinding_point_arg_ref, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
46504 uint64_t ret_ref = 0;
46505 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46506 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46510 static inline uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg) {
46511 LDKBlindedTail ret_var = BlindedTail_clone(arg);
46512 uint64_t ret_ref = 0;
46513 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46514 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46517 int64_t __attribute__((export_name("TS_BlindedTail_clone_ptr"))) TS_BlindedTail_clone_ptr(uint64_t arg) {
46518 LDKBlindedTail arg_conv;
46519 arg_conv.inner = untag_ptr(arg);
46520 arg_conv.is_owned = ptr_is_owned(arg);
46521 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46522 arg_conv.is_owned = false;
46523 int64_t ret_conv = BlindedTail_clone_ptr(&arg_conv);
46527 uint64_t __attribute__((export_name("TS_BlindedTail_clone"))) TS_BlindedTail_clone(uint64_t orig) {
46528 LDKBlindedTail orig_conv;
46529 orig_conv.inner = untag_ptr(orig);
46530 orig_conv.is_owned = ptr_is_owned(orig);
46531 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46532 orig_conv.is_owned = false;
46533 LDKBlindedTail ret_var = BlindedTail_clone(&orig_conv);
46534 uint64_t ret_ref = 0;
46535 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46536 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46540 int64_t __attribute__((export_name("TS_BlindedTail_hash"))) TS_BlindedTail_hash(uint64_t o) {
46541 LDKBlindedTail o_conv;
46542 o_conv.inner = untag_ptr(o);
46543 o_conv.is_owned = ptr_is_owned(o);
46544 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46545 o_conv.is_owned = false;
46546 int64_t ret_conv = BlindedTail_hash(&o_conv);
46550 jboolean __attribute__((export_name("TS_BlindedTail_eq"))) TS_BlindedTail_eq(uint64_t a, uint64_t b) {
46551 LDKBlindedTail a_conv;
46552 a_conv.inner = untag_ptr(a);
46553 a_conv.is_owned = ptr_is_owned(a);
46554 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46555 a_conv.is_owned = false;
46556 LDKBlindedTail b_conv;
46557 b_conv.inner = untag_ptr(b);
46558 b_conv.is_owned = ptr_is_owned(b);
46559 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46560 b_conv.is_owned = false;
46561 jboolean ret_conv = BlindedTail_eq(&a_conv, &b_conv);
46565 int8_tArray __attribute__((export_name("TS_BlindedTail_write"))) TS_BlindedTail_write(uint64_t obj) {
46566 LDKBlindedTail obj_conv;
46567 obj_conv.inner = untag_ptr(obj);
46568 obj_conv.is_owned = ptr_is_owned(obj);
46569 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46570 obj_conv.is_owned = false;
46571 LDKCVec_u8Z ret_var = BlindedTail_write(&obj_conv);
46572 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46573 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46574 CVec_u8Z_free(ret_var);
46578 uint64_t __attribute__((export_name("TS_BlindedTail_read"))) TS_BlindedTail_read(int8_tArray ser) {
46579 LDKu8slice ser_ref;
46580 ser_ref.datalen = ser->arr_len;
46581 ser_ref.data = ser->elems;
46582 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
46583 *ret_conv = BlindedTail_read(ser_ref);
46585 return tag_ptr(ret_conv, true);
46588 void __attribute__((export_name("TS_Path_free"))) TS_Path_free(uint64_t this_obj) {
46589 LDKPath this_obj_conv;
46590 this_obj_conv.inner = untag_ptr(this_obj);
46591 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46593 Path_free(this_obj_conv);
46596 uint64_tArray __attribute__((export_name("TS_Path_get_hops"))) TS_Path_get_hops(uint64_t this_ptr) {
46597 LDKPath this_ptr_conv;
46598 this_ptr_conv.inner = untag_ptr(this_ptr);
46599 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46601 this_ptr_conv.is_owned = false;
46602 LDKCVec_RouteHopZ ret_var = Path_get_hops(&this_ptr_conv);
46603 uint64_tArray ret_arr = NULL;
46604 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46605 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46606 for (size_t k = 0; k < ret_var.datalen; k++) {
46607 LDKRouteHop ret_conv_10_var = ret_var.data[k];
46608 uint64_t ret_conv_10_ref = 0;
46609 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
46610 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
46611 ret_arr_ptr[k] = ret_conv_10_ref;
46614 FREE(ret_var.data);
46618 void __attribute__((export_name("TS_Path_set_hops"))) TS_Path_set_hops(uint64_t this_ptr, uint64_tArray val) {
46619 LDKPath this_ptr_conv;
46620 this_ptr_conv.inner = untag_ptr(this_ptr);
46621 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46622 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46623 this_ptr_conv.is_owned = false;
46624 LDKCVec_RouteHopZ val_constr;
46625 val_constr.datalen = val->arr_len;
46626 if (val_constr.datalen > 0)
46627 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
46629 val_constr.data = NULL;
46630 uint64_t* val_vals = val->elems;
46631 for (size_t k = 0; k < val_constr.datalen; k++) {
46632 uint64_t val_conv_10 = val_vals[k];
46633 LDKRouteHop val_conv_10_conv;
46634 val_conv_10_conv.inner = untag_ptr(val_conv_10);
46635 val_conv_10_conv.is_owned = ptr_is_owned(val_conv_10);
46636 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_10_conv);
46637 val_conv_10_conv = RouteHop_clone(&val_conv_10_conv);
46638 val_constr.data[k] = val_conv_10_conv;
46641 Path_set_hops(&this_ptr_conv, val_constr);
46644 uint64_t __attribute__((export_name("TS_Path_get_blinded_tail"))) TS_Path_get_blinded_tail(uint64_t this_ptr) {
46645 LDKPath this_ptr_conv;
46646 this_ptr_conv.inner = untag_ptr(this_ptr);
46647 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46649 this_ptr_conv.is_owned = false;
46650 LDKBlindedTail ret_var = Path_get_blinded_tail(&this_ptr_conv);
46651 uint64_t ret_ref = 0;
46652 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46653 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46657 void __attribute__((export_name("TS_Path_set_blinded_tail"))) TS_Path_set_blinded_tail(uint64_t this_ptr, uint64_t val) {
46658 LDKPath this_ptr_conv;
46659 this_ptr_conv.inner = untag_ptr(this_ptr);
46660 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46661 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46662 this_ptr_conv.is_owned = false;
46663 LDKBlindedTail val_conv;
46664 val_conv.inner = untag_ptr(val);
46665 val_conv.is_owned = ptr_is_owned(val);
46666 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46667 val_conv = BlindedTail_clone(&val_conv);
46668 Path_set_blinded_tail(&this_ptr_conv, val_conv);
46671 uint64_t __attribute__((export_name("TS_Path_new"))) TS_Path_new(uint64_tArray hops_arg, uint64_t blinded_tail_arg) {
46672 LDKCVec_RouteHopZ hops_arg_constr;
46673 hops_arg_constr.datalen = hops_arg->arr_len;
46674 if (hops_arg_constr.datalen > 0)
46675 hops_arg_constr.data = MALLOC(hops_arg_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
46677 hops_arg_constr.data = NULL;
46678 uint64_t* hops_arg_vals = hops_arg->elems;
46679 for (size_t k = 0; k < hops_arg_constr.datalen; k++) {
46680 uint64_t hops_arg_conv_10 = hops_arg_vals[k];
46681 LDKRouteHop hops_arg_conv_10_conv;
46682 hops_arg_conv_10_conv.inner = untag_ptr(hops_arg_conv_10);
46683 hops_arg_conv_10_conv.is_owned = ptr_is_owned(hops_arg_conv_10);
46684 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_arg_conv_10_conv);
46685 hops_arg_conv_10_conv = RouteHop_clone(&hops_arg_conv_10_conv);
46686 hops_arg_constr.data[k] = hops_arg_conv_10_conv;
46689 LDKBlindedTail blinded_tail_arg_conv;
46690 blinded_tail_arg_conv.inner = untag_ptr(blinded_tail_arg);
46691 blinded_tail_arg_conv.is_owned = ptr_is_owned(blinded_tail_arg);
46692 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_tail_arg_conv);
46693 blinded_tail_arg_conv = BlindedTail_clone(&blinded_tail_arg_conv);
46694 LDKPath ret_var = Path_new(hops_arg_constr, blinded_tail_arg_conv);
46695 uint64_t ret_ref = 0;
46696 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46697 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46701 static inline uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg) {
46702 LDKPath ret_var = Path_clone(arg);
46703 uint64_t ret_ref = 0;
46704 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46705 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46708 int64_t __attribute__((export_name("TS_Path_clone_ptr"))) TS_Path_clone_ptr(uint64_t arg) {
46710 arg_conv.inner = untag_ptr(arg);
46711 arg_conv.is_owned = ptr_is_owned(arg);
46712 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46713 arg_conv.is_owned = false;
46714 int64_t ret_conv = Path_clone_ptr(&arg_conv);
46718 uint64_t __attribute__((export_name("TS_Path_clone"))) TS_Path_clone(uint64_t orig) {
46720 orig_conv.inner = untag_ptr(orig);
46721 orig_conv.is_owned = ptr_is_owned(orig);
46722 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46723 orig_conv.is_owned = false;
46724 LDKPath ret_var = Path_clone(&orig_conv);
46725 uint64_t ret_ref = 0;
46726 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46727 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46731 int64_t __attribute__((export_name("TS_Path_hash"))) TS_Path_hash(uint64_t o) {
46733 o_conv.inner = untag_ptr(o);
46734 o_conv.is_owned = ptr_is_owned(o);
46735 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46736 o_conv.is_owned = false;
46737 int64_t ret_conv = Path_hash(&o_conv);
46741 jboolean __attribute__((export_name("TS_Path_eq"))) TS_Path_eq(uint64_t a, uint64_t b) {
46743 a_conv.inner = untag_ptr(a);
46744 a_conv.is_owned = ptr_is_owned(a);
46745 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46746 a_conv.is_owned = false;
46748 b_conv.inner = untag_ptr(b);
46749 b_conv.is_owned = ptr_is_owned(b);
46750 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46751 b_conv.is_owned = false;
46752 jboolean ret_conv = Path_eq(&a_conv, &b_conv);
46756 int64_t __attribute__((export_name("TS_Path_fee_msat"))) TS_Path_fee_msat(uint64_t this_arg) {
46757 LDKPath this_arg_conv;
46758 this_arg_conv.inner = untag_ptr(this_arg);
46759 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46761 this_arg_conv.is_owned = false;
46762 int64_t ret_conv = Path_fee_msat(&this_arg_conv);
46766 int64_t __attribute__((export_name("TS_Path_final_value_msat"))) TS_Path_final_value_msat(uint64_t this_arg) {
46767 LDKPath this_arg_conv;
46768 this_arg_conv.inner = untag_ptr(this_arg);
46769 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46771 this_arg_conv.is_owned = false;
46772 int64_t ret_conv = Path_final_value_msat(&this_arg_conv);
46776 uint64_t __attribute__((export_name("TS_Path_final_cltv_expiry_delta"))) TS_Path_final_cltv_expiry_delta(uint64_t this_arg) {
46777 LDKPath this_arg_conv;
46778 this_arg_conv.inner = untag_ptr(this_arg);
46779 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46781 this_arg_conv.is_owned = false;
46782 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
46783 *ret_copy = Path_final_cltv_expiry_delta(&this_arg_conv);
46784 uint64_t ret_ref = tag_ptr(ret_copy, true);
46788 void __attribute__((export_name("TS_Route_free"))) TS_Route_free(uint64_t this_obj) {
46789 LDKRoute this_obj_conv;
46790 this_obj_conv.inner = untag_ptr(this_obj);
46791 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46792 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46793 Route_free(this_obj_conv);
46796 uint64_tArray __attribute__((export_name("TS_Route_get_paths"))) TS_Route_get_paths(uint64_t this_ptr) {
46797 LDKRoute this_ptr_conv;
46798 this_ptr_conv.inner = untag_ptr(this_ptr);
46799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46801 this_ptr_conv.is_owned = false;
46802 LDKCVec_PathZ ret_var = Route_get_paths(&this_ptr_conv);
46803 uint64_tArray ret_arr = NULL;
46804 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46805 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46806 for (size_t g = 0; g < ret_var.datalen; g++) {
46807 LDKPath ret_conv_6_var = ret_var.data[g];
46808 uint64_t ret_conv_6_ref = 0;
46809 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_6_var);
46810 ret_conv_6_ref = tag_ptr(ret_conv_6_var.inner, ret_conv_6_var.is_owned);
46811 ret_arr_ptr[g] = ret_conv_6_ref;
46814 FREE(ret_var.data);
46818 void __attribute__((export_name("TS_Route_set_paths"))) TS_Route_set_paths(uint64_t this_ptr, uint64_tArray val) {
46819 LDKRoute this_ptr_conv;
46820 this_ptr_conv.inner = untag_ptr(this_ptr);
46821 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46823 this_ptr_conv.is_owned = false;
46824 LDKCVec_PathZ val_constr;
46825 val_constr.datalen = val->arr_len;
46826 if (val_constr.datalen > 0)
46827 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
46829 val_constr.data = NULL;
46830 uint64_t* val_vals = val->elems;
46831 for (size_t g = 0; g < val_constr.datalen; g++) {
46832 uint64_t val_conv_6 = val_vals[g];
46833 LDKPath val_conv_6_conv;
46834 val_conv_6_conv.inner = untag_ptr(val_conv_6);
46835 val_conv_6_conv.is_owned = ptr_is_owned(val_conv_6);
46836 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_6_conv);
46837 val_conv_6_conv = Path_clone(&val_conv_6_conv);
46838 val_constr.data[g] = val_conv_6_conv;
46841 Route_set_paths(&this_ptr_conv, val_constr);
46844 uint64_t __attribute__((export_name("TS_Route_get_payment_params"))) TS_Route_get_payment_params(uint64_t this_ptr) {
46845 LDKRoute this_ptr_conv;
46846 this_ptr_conv.inner = untag_ptr(this_ptr);
46847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46849 this_ptr_conv.is_owned = false;
46850 LDKPaymentParameters ret_var = Route_get_payment_params(&this_ptr_conv);
46851 uint64_t ret_ref = 0;
46852 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46853 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46857 void __attribute__((export_name("TS_Route_set_payment_params"))) TS_Route_set_payment_params(uint64_t this_ptr, uint64_t val) {
46858 LDKRoute this_ptr_conv;
46859 this_ptr_conv.inner = untag_ptr(this_ptr);
46860 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46862 this_ptr_conv.is_owned = false;
46863 LDKPaymentParameters val_conv;
46864 val_conv.inner = untag_ptr(val);
46865 val_conv.is_owned = ptr_is_owned(val);
46866 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46867 val_conv = PaymentParameters_clone(&val_conv);
46868 Route_set_payment_params(&this_ptr_conv, val_conv);
46871 uint64_t __attribute__((export_name("TS_Route_new"))) TS_Route_new(uint64_tArray paths_arg, uint64_t payment_params_arg) {
46872 LDKCVec_PathZ paths_arg_constr;
46873 paths_arg_constr.datalen = paths_arg->arr_len;
46874 if (paths_arg_constr.datalen > 0)
46875 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
46877 paths_arg_constr.data = NULL;
46878 uint64_t* paths_arg_vals = paths_arg->elems;
46879 for (size_t g = 0; g < paths_arg_constr.datalen; g++) {
46880 uint64_t paths_arg_conv_6 = paths_arg_vals[g];
46881 LDKPath paths_arg_conv_6_conv;
46882 paths_arg_conv_6_conv.inner = untag_ptr(paths_arg_conv_6);
46883 paths_arg_conv_6_conv.is_owned = ptr_is_owned(paths_arg_conv_6);
46884 CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_6_conv);
46885 paths_arg_conv_6_conv = Path_clone(&paths_arg_conv_6_conv);
46886 paths_arg_constr.data[g] = paths_arg_conv_6_conv;
46889 LDKPaymentParameters payment_params_arg_conv;
46890 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
46891 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
46892 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
46893 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
46894 LDKRoute ret_var = Route_new(paths_arg_constr, payment_params_arg_conv);
46895 uint64_t ret_ref = 0;
46896 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46897 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46901 static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
46902 LDKRoute ret_var = Route_clone(arg);
46903 uint64_t ret_ref = 0;
46904 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46905 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46908 int64_t __attribute__((export_name("TS_Route_clone_ptr"))) TS_Route_clone_ptr(uint64_t arg) {
46910 arg_conv.inner = untag_ptr(arg);
46911 arg_conv.is_owned = ptr_is_owned(arg);
46912 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46913 arg_conv.is_owned = false;
46914 int64_t ret_conv = Route_clone_ptr(&arg_conv);
46918 uint64_t __attribute__((export_name("TS_Route_clone"))) TS_Route_clone(uint64_t orig) {
46919 LDKRoute orig_conv;
46920 orig_conv.inner = untag_ptr(orig);
46921 orig_conv.is_owned = ptr_is_owned(orig);
46922 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46923 orig_conv.is_owned = false;
46924 LDKRoute ret_var = Route_clone(&orig_conv);
46925 uint64_t ret_ref = 0;
46926 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46927 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46931 int64_t __attribute__((export_name("TS_Route_hash"))) TS_Route_hash(uint64_t o) {
46933 o_conv.inner = untag_ptr(o);
46934 o_conv.is_owned = ptr_is_owned(o);
46935 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46936 o_conv.is_owned = false;
46937 int64_t ret_conv = Route_hash(&o_conv);
46941 jboolean __attribute__((export_name("TS_Route_eq"))) TS_Route_eq(uint64_t a, uint64_t b) {
46943 a_conv.inner = untag_ptr(a);
46944 a_conv.is_owned = ptr_is_owned(a);
46945 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46946 a_conv.is_owned = false;
46948 b_conv.inner = untag_ptr(b);
46949 b_conv.is_owned = ptr_is_owned(b);
46950 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46951 b_conv.is_owned = false;
46952 jboolean ret_conv = Route_eq(&a_conv, &b_conv);
46956 int64_t __attribute__((export_name("TS_Route_get_total_fees"))) TS_Route_get_total_fees(uint64_t this_arg) {
46957 LDKRoute this_arg_conv;
46958 this_arg_conv.inner = untag_ptr(this_arg);
46959 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46961 this_arg_conv.is_owned = false;
46962 int64_t ret_conv = Route_get_total_fees(&this_arg_conv);
46966 int64_t __attribute__((export_name("TS_Route_get_total_amount"))) TS_Route_get_total_amount(uint64_t this_arg) {
46967 LDKRoute this_arg_conv;
46968 this_arg_conv.inner = untag_ptr(this_arg);
46969 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46971 this_arg_conv.is_owned = false;
46972 int64_t ret_conv = Route_get_total_amount(&this_arg_conv);
46976 int8_tArray __attribute__((export_name("TS_Route_write"))) TS_Route_write(uint64_t obj) {
46978 obj_conv.inner = untag_ptr(obj);
46979 obj_conv.is_owned = ptr_is_owned(obj);
46980 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46981 obj_conv.is_owned = false;
46982 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
46983 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46984 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46985 CVec_u8Z_free(ret_var);
46989 uint64_t __attribute__((export_name("TS_Route_read"))) TS_Route_read(int8_tArray ser) {
46990 LDKu8slice ser_ref;
46991 ser_ref.datalen = ser->arr_len;
46992 ser_ref.data = ser->elems;
46993 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
46994 *ret_conv = Route_read(ser_ref);
46996 return tag_ptr(ret_conv, true);
46999 void __attribute__((export_name("TS_RouteParameters_free"))) TS_RouteParameters_free(uint64_t this_obj) {
47000 LDKRouteParameters this_obj_conv;
47001 this_obj_conv.inner = untag_ptr(this_obj);
47002 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47004 RouteParameters_free(this_obj_conv);
47007 uint64_t __attribute__((export_name("TS_RouteParameters_get_payment_params"))) TS_RouteParameters_get_payment_params(uint64_t this_ptr) {
47008 LDKRouteParameters this_ptr_conv;
47009 this_ptr_conv.inner = untag_ptr(this_ptr);
47010 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47012 this_ptr_conv.is_owned = false;
47013 LDKPaymentParameters ret_var = RouteParameters_get_payment_params(&this_ptr_conv);
47014 uint64_t ret_ref = 0;
47015 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47016 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47020 void __attribute__((export_name("TS_RouteParameters_set_payment_params"))) TS_RouteParameters_set_payment_params(uint64_t this_ptr, uint64_t val) {
47021 LDKRouteParameters this_ptr_conv;
47022 this_ptr_conv.inner = untag_ptr(this_ptr);
47023 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47025 this_ptr_conv.is_owned = false;
47026 LDKPaymentParameters val_conv;
47027 val_conv.inner = untag_ptr(val);
47028 val_conv.is_owned = ptr_is_owned(val);
47029 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47030 val_conv = PaymentParameters_clone(&val_conv);
47031 RouteParameters_set_payment_params(&this_ptr_conv, val_conv);
47034 int64_t __attribute__((export_name("TS_RouteParameters_get_final_value_msat"))) TS_RouteParameters_get_final_value_msat(uint64_t this_ptr) {
47035 LDKRouteParameters this_ptr_conv;
47036 this_ptr_conv.inner = untag_ptr(this_ptr);
47037 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47039 this_ptr_conv.is_owned = false;
47040 int64_t ret_conv = RouteParameters_get_final_value_msat(&this_ptr_conv);
47044 void __attribute__((export_name("TS_RouteParameters_set_final_value_msat"))) TS_RouteParameters_set_final_value_msat(uint64_t this_ptr, int64_t val) {
47045 LDKRouteParameters this_ptr_conv;
47046 this_ptr_conv.inner = untag_ptr(this_ptr);
47047 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47048 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47049 this_ptr_conv.is_owned = false;
47050 RouteParameters_set_final_value_msat(&this_ptr_conv, val);
47053 uint64_t __attribute__((export_name("TS_RouteParameters_new"))) TS_RouteParameters_new(uint64_t payment_params_arg, int64_t final_value_msat_arg) {
47054 LDKPaymentParameters payment_params_arg_conv;
47055 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
47056 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
47057 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
47058 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
47059 LDKRouteParameters ret_var = RouteParameters_new(payment_params_arg_conv, final_value_msat_arg);
47060 uint64_t ret_ref = 0;
47061 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47062 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47066 static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
47067 LDKRouteParameters ret_var = RouteParameters_clone(arg);
47068 uint64_t ret_ref = 0;
47069 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47070 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47073 int64_t __attribute__((export_name("TS_RouteParameters_clone_ptr"))) TS_RouteParameters_clone_ptr(uint64_t arg) {
47074 LDKRouteParameters arg_conv;
47075 arg_conv.inner = untag_ptr(arg);
47076 arg_conv.is_owned = ptr_is_owned(arg);
47077 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47078 arg_conv.is_owned = false;
47079 int64_t ret_conv = RouteParameters_clone_ptr(&arg_conv);
47083 uint64_t __attribute__((export_name("TS_RouteParameters_clone"))) TS_RouteParameters_clone(uint64_t orig) {
47084 LDKRouteParameters orig_conv;
47085 orig_conv.inner = untag_ptr(orig);
47086 orig_conv.is_owned = ptr_is_owned(orig);
47087 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47088 orig_conv.is_owned = false;
47089 LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
47090 uint64_t ret_ref = 0;
47091 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47092 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47096 jboolean __attribute__((export_name("TS_RouteParameters_eq"))) TS_RouteParameters_eq(uint64_t a, uint64_t b) {
47097 LDKRouteParameters a_conv;
47098 a_conv.inner = untag_ptr(a);
47099 a_conv.is_owned = ptr_is_owned(a);
47100 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47101 a_conv.is_owned = false;
47102 LDKRouteParameters b_conv;
47103 b_conv.inner = untag_ptr(b);
47104 b_conv.is_owned = ptr_is_owned(b);
47105 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47106 b_conv.is_owned = false;
47107 jboolean ret_conv = RouteParameters_eq(&a_conv, &b_conv);
47111 int8_tArray __attribute__((export_name("TS_RouteParameters_write"))) TS_RouteParameters_write(uint64_t obj) {
47112 LDKRouteParameters obj_conv;
47113 obj_conv.inner = untag_ptr(obj);
47114 obj_conv.is_owned = ptr_is_owned(obj);
47115 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47116 obj_conv.is_owned = false;
47117 LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
47118 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47119 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47120 CVec_u8Z_free(ret_var);
47124 uint64_t __attribute__((export_name("TS_RouteParameters_read"))) TS_RouteParameters_read(int8_tArray ser) {
47125 LDKu8slice ser_ref;
47126 ser_ref.datalen = ser->arr_len;
47127 ser_ref.data = ser->elems;
47128 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
47129 *ret_conv = RouteParameters_read(ser_ref);
47131 return tag_ptr(ret_conv, true);
47134 void __attribute__((export_name("TS_PaymentParameters_free"))) TS_PaymentParameters_free(uint64_t this_obj) {
47135 LDKPaymentParameters this_obj_conv;
47136 this_obj_conv.inner = untag_ptr(this_obj);
47137 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47139 PaymentParameters_free(this_obj_conv);
47142 int8_tArray __attribute__((export_name("TS_PaymentParameters_get_payee_pubkey"))) TS_PaymentParameters_get_payee_pubkey(uint64_t this_ptr) {
47143 LDKPaymentParameters this_ptr_conv;
47144 this_ptr_conv.inner = untag_ptr(this_ptr);
47145 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47146 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47147 this_ptr_conv.is_owned = false;
47148 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47149 memcpy(ret_arr->elems, PaymentParameters_get_payee_pubkey(&this_ptr_conv).compressed_form, 33);
47153 void __attribute__((export_name("TS_PaymentParameters_set_payee_pubkey"))) TS_PaymentParameters_set_payee_pubkey(uint64_t this_ptr, int8_tArray val) {
47154 LDKPaymentParameters this_ptr_conv;
47155 this_ptr_conv.inner = untag_ptr(this_ptr);
47156 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47157 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47158 this_ptr_conv.is_owned = false;
47159 LDKPublicKey val_ref;
47160 CHECK(val->arr_len == 33);
47161 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47162 PaymentParameters_set_payee_pubkey(&this_ptr_conv, val_ref);
47165 uint64_t __attribute__((export_name("TS_PaymentParameters_get_features"))) TS_PaymentParameters_get_features(uint64_t this_ptr) {
47166 LDKPaymentParameters this_ptr_conv;
47167 this_ptr_conv.inner = untag_ptr(this_ptr);
47168 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47170 this_ptr_conv.is_owned = false;
47171 LDKInvoiceFeatures ret_var = PaymentParameters_get_features(&this_ptr_conv);
47172 uint64_t ret_ref = 0;
47173 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47174 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47178 void __attribute__((export_name("TS_PaymentParameters_set_features"))) TS_PaymentParameters_set_features(uint64_t this_ptr, uint64_t val) {
47179 LDKPaymentParameters this_ptr_conv;
47180 this_ptr_conv.inner = untag_ptr(this_ptr);
47181 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47182 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47183 this_ptr_conv.is_owned = false;
47184 LDKInvoiceFeatures val_conv;
47185 val_conv.inner = untag_ptr(val);
47186 val_conv.is_owned = ptr_is_owned(val);
47187 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47188 val_conv = InvoiceFeatures_clone(&val_conv);
47189 PaymentParameters_set_features(&this_ptr_conv, val_conv);
47192 uint64_t __attribute__((export_name("TS_PaymentParameters_get_route_hints"))) TS_PaymentParameters_get_route_hints(uint64_t this_ptr) {
47193 LDKPaymentParameters this_ptr_conv;
47194 this_ptr_conv.inner = untag_ptr(this_ptr);
47195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47197 this_ptr_conv.is_owned = false;
47198 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47199 *ret_copy = PaymentParameters_get_route_hints(&this_ptr_conv);
47200 uint64_t ret_ref = tag_ptr(ret_copy, true);
47204 void __attribute__((export_name("TS_PaymentParameters_set_route_hints"))) TS_PaymentParameters_set_route_hints(uint64_t this_ptr, uint64_t val) {
47205 LDKPaymentParameters this_ptr_conv;
47206 this_ptr_conv.inner = untag_ptr(this_ptr);
47207 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47209 this_ptr_conv.is_owned = false;
47210 void* val_ptr = untag_ptr(val);
47211 CHECK_ACCESS(val_ptr);
47212 LDKHints val_conv = *(LDKHints*)(val_ptr);
47213 val_conv = Hints_clone((LDKHints*)untag_ptr(val));
47214 PaymentParameters_set_route_hints(&this_ptr_conv, val_conv);
47217 uint64_t __attribute__((export_name("TS_PaymentParameters_get_expiry_time"))) TS_PaymentParameters_get_expiry_time(uint64_t this_ptr) {
47218 LDKPaymentParameters this_ptr_conv;
47219 this_ptr_conv.inner = untag_ptr(this_ptr);
47220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47222 this_ptr_conv.is_owned = false;
47223 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47224 *ret_copy = PaymentParameters_get_expiry_time(&this_ptr_conv);
47225 uint64_t ret_ref = tag_ptr(ret_copy, true);
47229 void __attribute__((export_name("TS_PaymentParameters_set_expiry_time"))) TS_PaymentParameters_set_expiry_time(uint64_t this_ptr, uint64_t val) {
47230 LDKPaymentParameters this_ptr_conv;
47231 this_ptr_conv.inner = untag_ptr(this_ptr);
47232 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47234 this_ptr_conv.is_owned = false;
47235 void* val_ptr = untag_ptr(val);
47236 CHECK_ACCESS(val_ptr);
47237 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
47238 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
47239 PaymentParameters_set_expiry_time(&this_ptr_conv, val_conv);
47242 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) {
47243 LDKPaymentParameters this_ptr_conv;
47244 this_ptr_conv.inner = untag_ptr(this_ptr);
47245 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47246 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47247 this_ptr_conv.is_owned = false;
47248 int32_t ret_conv = PaymentParameters_get_max_total_cltv_expiry_delta(&this_ptr_conv);
47252 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) {
47253 LDKPaymentParameters this_ptr_conv;
47254 this_ptr_conv.inner = untag_ptr(this_ptr);
47255 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47257 this_ptr_conv.is_owned = false;
47258 PaymentParameters_set_max_total_cltv_expiry_delta(&this_ptr_conv, val);
47261 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_path_count"))) TS_PaymentParameters_get_max_path_count(uint64_t this_ptr) {
47262 LDKPaymentParameters this_ptr_conv;
47263 this_ptr_conv.inner = untag_ptr(this_ptr);
47264 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47266 this_ptr_conv.is_owned = false;
47267 int8_t ret_conv = PaymentParameters_get_max_path_count(&this_ptr_conv);
47271 void __attribute__((export_name("TS_PaymentParameters_set_max_path_count"))) TS_PaymentParameters_set_max_path_count(uint64_t this_ptr, int8_t val) {
47272 LDKPaymentParameters this_ptr_conv;
47273 this_ptr_conv.inner = untag_ptr(this_ptr);
47274 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47276 this_ptr_conv.is_owned = false;
47277 PaymentParameters_set_max_path_count(&this_ptr_conv, val);
47280 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) {
47281 LDKPaymentParameters this_ptr_conv;
47282 this_ptr_conv.inner = untag_ptr(this_ptr);
47283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47285 this_ptr_conv.is_owned = false;
47286 int8_t ret_conv = PaymentParameters_get_max_channel_saturation_power_of_half(&this_ptr_conv);
47290 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) {
47291 LDKPaymentParameters this_ptr_conv;
47292 this_ptr_conv.inner = untag_ptr(this_ptr);
47293 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47295 this_ptr_conv.is_owned = false;
47296 PaymentParameters_set_max_channel_saturation_power_of_half(&this_ptr_conv, val);
47299 int64_tArray __attribute__((export_name("TS_PaymentParameters_get_previously_failed_channels"))) TS_PaymentParameters_get_previously_failed_channels(uint64_t this_ptr) {
47300 LDKPaymentParameters this_ptr_conv;
47301 this_ptr_conv.inner = untag_ptr(this_ptr);
47302 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47304 this_ptr_conv.is_owned = false;
47305 LDKCVec_u64Z ret_var = PaymentParameters_get_previously_failed_channels(&this_ptr_conv);
47306 int64_tArray ret_arr = NULL;
47307 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
47308 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
47309 for (size_t i = 0; i < ret_var.datalen; i++) {
47310 int64_t ret_conv_8_conv = ret_var.data[i];
47311 ret_arr_ptr[i] = ret_conv_8_conv;
47314 FREE(ret_var.data);
47318 void __attribute__((export_name("TS_PaymentParameters_set_previously_failed_channels"))) TS_PaymentParameters_set_previously_failed_channels(uint64_t this_ptr, int64_tArray val) {
47319 LDKPaymentParameters this_ptr_conv;
47320 this_ptr_conv.inner = untag_ptr(this_ptr);
47321 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47322 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47323 this_ptr_conv.is_owned = false;
47324 LDKCVec_u64Z val_constr;
47325 val_constr.datalen = val->arr_len;
47326 if (val_constr.datalen > 0)
47327 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
47329 val_constr.data = NULL;
47330 int64_t* val_vals = val->elems;
47331 for (size_t i = 0; i < val_constr.datalen; i++) {
47332 int64_t val_conv_8 = val_vals[i];
47333 val_constr.data[i] = val_conv_8;
47336 PaymentParameters_set_previously_failed_channels(&this_ptr_conv, val_constr);
47339 int32_t __attribute__((export_name("TS_PaymentParameters_get_final_cltv_expiry_delta"))) TS_PaymentParameters_get_final_cltv_expiry_delta(uint64_t this_ptr) {
47340 LDKPaymentParameters this_ptr_conv;
47341 this_ptr_conv.inner = untag_ptr(this_ptr);
47342 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47344 this_ptr_conv.is_owned = false;
47345 int32_t ret_conv = PaymentParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
47349 void __attribute__((export_name("TS_PaymentParameters_set_final_cltv_expiry_delta"))) TS_PaymentParameters_set_final_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
47350 LDKPaymentParameters this_ptr_conv;
47351 this_ptr_conv.inner = untag_ptr(this_ptr);
47352 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47354 this_ptr_conv.is_owned = false;
47355 PaymentParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
47358 uint64_t __attribute__((export_name("TS_PaymentParameters_new"))) TS_PaymentParameters_new(int8_tArray payee_pubkey_arg, uint64_t features_arg, uint64_t 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, int32_t final_cltv_expiry_delta_arg) {
47359 LDKPublicKey payee_pubkey_arg_ref;
47360 CHECK(payee_pubkey_arg->arr_len == 33);
47361 memcpy(payee_pubkey_arg_ref.compressed_form, payee_pubkey_arg->elems, 33); FREE(payee_pubkey_arg);
47362 LDKInvoiceFeatures features_arg_conv;
47363 features_arg_conv.inner = untag_ptr(features_arg);
47364 features_arg_conv.is_owned = ptr_is_owned(features_arg);
47365 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
47366 features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
47367 void* route_hints_arg_ptr = untag_ptr(route_hints_arg);
47368 CHECK_ACCESS(route_hints_arg_ptr);
47369 LDKHints route_hints_arg_conv = *(LDKHints*)(route_hints_arg_ptr);
47370 route_hints_arg_conv = Hints_clone((LDKHints*)untag_ptr(route_hints_arg));
47371 void* expiry_time_arg_ptr = untag_ptr(expiry_time_arg);
47372 CHECK_ACCESS(expiry_time_arg_ptr);
47373 LDKCOption_u64Z expiry_time_arg_conv = *(LDKCOption_u64Z*)(expiry_time_arg_ptr);
47374 expiry_time_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(expiry_time_arg));
47375 LDKCVec_u64Z previously_failed_channels_arg_constr;
47376 previously_failed_channels_arg_constr.datalen = previously_failed_channels_arg->arr_len;
47377 if (previously_failed_channels_arg_constr.datalen > 0)
47378 previously_failed_channels_arg_constr.data = MALLOC(previously_failed_channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
47380 previously_failed_channels_arg_constr.data = NULL;
47381 int64_t* previously_failed_channels_arg_vals = previously_failed_channels_arg->elems;
47382 for (size_t i = 0; i < previously_failed_channels_arg_constr.datalen; i++) {
47383 int64_t previously_failed_channels_arg_conv_8 = previously_failed_channels_arg_vals[i];
47384 previously_failed_channels_arg_constr.data[i] = previously_failed_channels_arg_conv_8;
47386 FREE(previously_failed_channels_arg);
47387 LDKPaymentParameters ret_var = PaymentParameters_new(payee_pubkey_arg_ref, features_arg_conv, route_hints_arg_conv, 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, final_cltv_expiry_delta_arg);
47388 uint64_t ret_ref = 0;
47389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47394 static inline uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg) {
47395 LDKPaymentParameters ret_var = PaymentParameters_clone(arg);
47396 uint64_t ret_ref = 0;
47397 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47398 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47401 int64_t __attribute__((export_name("TS_PaymentParameters_clone_ptr"))) TS_PaymentParameters_clone_ptr(uint64_t arg) {
47402 LDKPaymentParameters arg_conv;
47403 arg_conv.inner = untag_ptr(arg);
47404 arg_conv.is_owned = ptr_is_owned(arg);
47405 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47406 arg_conv.is_owned = false;
47407 int64_t ret_conv = PaymentParameters_clone_ptr(&arg_conv);
47411 uint64_t __attribute__((export_name("TS_PaymentParameters_clone"))) TS_PaymentParameters_clone(uint64_t orig) {
47412 LDKPaymentParameters orig_conv;
47413 orig_conv.inner = untag_ptr(orig);
47414 orig_conv.is_owned = ptr_is_owned(orig);
47415 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47416 orig_conv.is_owned = false;
47417 LDKPaymentParameters ret_var = PaymentParameters_clone(&orig_conv);
47418 uint64_t ret_ref = 0;
47419 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47420 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47424 int64_t __attribute__((export_name("TS_PaymentParameters_hash"))) TS_PaymentParameters_hash(uint64_t o) {
47425 LDKPaymentParameters o_conv;
47426 o_conv.inner = untag_ptr(o);
47427 o_conv.is_owned = ptr_is_owned(o);
47428 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47429 o_conv.is_owned = false;
47430 int64_t ret_conv = PaymentParameters_hash(&o_conv);
47434 jboolean __attribute__((export_name("TS_PaymentParameters_eq"))) TS_PaymentParameters_eq(uint64_t a, uint64_t b) {
47435 LDKPaymentParameters a_conv;
47436 a_conv.inner = untag_ptr(a);
47437 a_conv.is_owned = ptr_is_owned(a);
47438 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47439 a_conv.is_owned = false;
47440 LDKPaymentParameters b_conv;
47441 b_conv.inner = untag_ptr(b);
47442 b_conv.is_owned = ptr_is_owned(b);
47443 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47444 b_conv.is_owned = false;
47445 jboolean ret_conv = PaymentParameters_eq(&a_conv, &b_conv);
47449 int8_tArray __attribute__((export_name("TS_PaymentParameters_write"))) TS_PaymentParameters_write(uint64_t obj) {
47450 LDKPaymentParameters obj_conv;
47451 obj_conv.inner = untag_ptr(obj);
47452 obj_conv.is_owned = ptr_is_owned(obj);
47453 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47454 obj_conv.is_owned = false;
47455 LDKCVec_u8Z ret_var = PaymentParameters_write(&obj_conv);
47456 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47457 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47458 CVec_u8Z_free(ret_var);
47462 uint64_t __attribute__((export_name("TS_PaymentParameters_read"))) TS_PaymentParameters_read(int8_tArray ser, int32_t arg) {
47463 LDKu8slice ser_ref;
47464 ser_ref.datalen = ser->arr_len;
47465 ser_ref.data = ser->elems;
47466 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
47467 *ret_conv = PaymentParameters_read(ser_ref, arg);
47469 return tag_ptr(ret_conv, true);
47472 uint64_t __attribute__((export_name("TS_PaymentParameters_from_node_id"))) TS_PaymentParameters_from_node_id(int8_tArray payee_pubkey, int32_t final_cltv_expiry_delta) {
47473 LDKPublicKey payee_pubkey_ref;
47474 CHECK(payee_pubkey->arr_len == 33);
47475 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
47476 LDKPaymentParameters ret_var = PaymentParameters_from_node_id(payee_pubkey_ref, final_cltv_expiry_delta);
47477 uint64_t ret_ref = 0;
47478 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47479 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47483 uint64_t __attribute__((export_name("TS_PaymentParameters_for_keysend"))) TS_PaymentParameters_for_keysend(int8_tArray payee_pubkey, int32_t final_cltv_expiry_delta) {
47484 LDKPublicKey payee_pubkey_ref;
47485 CHECK(payee_pubkey->arr_len == 33);
47486 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
47487 LDKPaymentParameters ret_var = PaymentParameters_for_keysend(payee_pubkey_ref, final_cltv_expiry_delta);
47488 uint64_t ret_ref = 0;
47489 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47490 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47494 void __attribute__((export_name("TS_Hints_free"))) TS_Hints_free(uint64_t this_ptr) {
47495 if (!ptr_is_owned(this_ptr)) return;
47496 void* this_ptr_ptr = untag_ptr(this_ptr);
47497 CHECK_ACCESS(this_ptr_ptr);
47498 LDKHints this_ptr_conv = *(LDKHints*)(this_ptr_ptr);
47499 FREE(untag_ptr(this_ptr));
47500 Hints_free(this_ptr_conv);
47503 static inline uint64_t Hints_clone_ptr(LDKHints *NONNULL_PTR arg) {
47504 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47505 *ret_copy = Hints_clone(arg);
47506 uint64_t ret_ref = tag_ptr(ret_copy, true);
47509 int64_t __attribute__((export_name("TS_Hints_clone_ptr"))) TS_Hints_clone_ptr(uint64_t arg) {
47510 LDKHints* arg_conv = (LDKHints*)untag_ptr(arg);
47511 int64_t ret_conv = Hints_clone_ptr(arg_conv);
47515 uint64_t __attribute__((export_name("TS_Hints_clone"))) TS_Hints_clone(uint64_t orig) {
47516 LDKHints* orig_conv = (LDKHints*)untag_ptr(orig);
47517 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47518 *ret_copy = Hints_clone(orig_conv);
47519 uint64_t ret_ref = tag_ptr(ret_copy, true);
47523 uint64_t __attribute__((export_name("TS_Hints_blinded"))) TS_Hints_blinded(uint64_tArray a) {
47524 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ a_constr;
47525 a_constr.datalen = a->arr_len;
47526 if (a_constr.datalen > 0)
47527 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
47529 a_constr.data = NULL;
47530 uint64_t* a_vals = a->elems;
47531 for (size_t l = 0; l < a_constr.datalen; l++) {
47532 uint64_t a_conv_37 = a_vals[l];
47533 void* a_conv_37_ptr = untag_ptr(a_conv_37);
47534 CHECK_ACCESS(a_conv_37_ptr);
47535 LDKC2Tuple_BlindedPayInfoBlindedPathZ a_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(a_conv_37_ptr);
47536 a_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone((LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(a_conv_37));
47537 a_constr.data[l] = a_conv_37_conv;
47540 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47541 *ret_copy = Hints_blinded(a_constr);
47542 uint64_t ret_ref = tag_ptr(ret_copy, true);
47546 uint64_t __attribute__((export_name("TS_Hints_clear"))) TS_Hints_clear(uint64_tArray a) {
47547 LDKCVec_RouteHintZ a_constr;
47548 a_constr.datalen = a->arr_len;
47549 if (a_constr.datalen > 0)
47550 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
47552 a_constr.data = NULL;
47553 uint64_t* a_vals = a->elems;
47554 for (size_t l = 0; l < a_constr.datalen; l++) {
47555 uint64_t a_conv_11 = a_vals[l];
47556 LDKRouteHint a_conv_11_conv;
47557 a_conv_11_conv.inner = untag_ptr(a_conv_11);
47558 a_conv_11_conv.is_owned = ptr_is_owned(a_conv_11);
47559 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv_11_conv);
47560 a_conv_11_conv = RouteHint_clone(&a_conv_11_conv);
47561 a_constr.data[l] = a_conv_11_conv;
47564 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47565 *ret_copy = Hints_clear(a_constr);
47566 uint64_t ret_ref = tag_ptr(ret_copy, true);
47570 int64_t __attribute__((export_name("TS_Hints_hash"))) TS_Hints_hash(uint64_t o) {
47571 LDKHints* o_conv = (LDKHints*)untag_ptr(o);
47572 int64_t ret_conv = Hints_hash(o_conv);
47576 jboolean __attribute__((export_name("TS_Hints_eq"))) TS_Hints_eq(uint64_t a, uint64_t b) {
47577 LDKHints* a_conv = (LDKHints*)untag_ptr(a);
47578 LDKHints* b_conv = (LDKHints*)untag_ptr(b);
47579 jboolean ret_conv = Hints_eq(a_conv, b_conv);
47583 void __attribute__((export_name("TS_RouteHint_free"))) TS_RouteHint_free(uint64_t this_obj) {
47584 LDKRouteHint this_obj_conv;
47585 this_obj_conv.inner = untag_ptr(this_obj);
47586 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47588 RouteHint_free(this_obj_conv);
47591 uint64_tArray __attribute__((export_name("TS_RouteHint_get_a"))) TS_RouteHint_get_a(uint64_t this_ptr) {
47592 LDKRouteHint this_ptr_conv;
47593 this_ptr_conv.inner = untag_ptr(this_ptr);
47594 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47596 this_ptr_conv.is_owned = false;
47597 LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
47598 uint64_tArray ret_arr = NULL;
47599 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
47600 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
47601 for (size_t o = 0; o < ret_var.datalen; o++) {
47602 LDKRouteHintHop ret_conv_14_var = ret_var.data[o];
47603 uint64_t ret_conv_14_ref = 0;
47604 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
47605 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
47606 ret_arr_ptr[o] = ret_conv_14_ref;
47609 FREE(ret_var.data);
47613 void __attribute__((export_name("TS_RouteHint_set_a"))) TS_RouteHint_set_a(uint64_t this_ptr, uint64_tArray val) {
47614 LDKRouteHint this_ptr_conv;
47615 this_ptr_conv.inner = untag_ptr(this_ptr);
47616 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47617 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47618 this_ptr_conv.is_owned = false;
47619 LDKCVec_RouteHintHopZ val_constr;
47620 val_constr.datalen = val->arr_len;
47621 if (val_constr.datalen > 0)
47622 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
47624 val_constr.data = NULL;
47625 uint64_t* val_vals = val->elems;
47626 for (size_t o = 0; o < val_constr.datalen; o++) {
47627 uint64_t val_conv_14 = val_vals[o];
47628 LDKRouteHintHop val_conv_14_conv;
47629 val_conv_14_conv.inner = untag_ptr(val_conv_14);
47630 val_conv_14_conv.is_owned = ptr_is_owned(val_conv_14);
47631 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
47632 val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
47633 val_constr.data[o] = val_conv_14_conv;
47636 RouteHint_set_a(&this_ptr_conv, val_constr);
47639 uint64_t __attribute__((export_name("TS_RouteHint_new"))) TS_RouteHint_new(uint64_tArray a_arg) {
47640 LDKCVec_RouteHintHopZ a_arg_constr;
47641 a_arg_constr.datalen = a_arg->arr_len;
47642 if (a_arg_constr.datalen > 0)
47643 a_arg_constr.data = MALLOC(a_arg_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
47645 a_arg_constr.data = NULL;
47646 uint64_t* a_arg_vals = a_arg->elems;
47647 for (size_t o = 0; o < a_arg_constr.datalen; o++) {
47648 uint64_t a_arg_conv_14 = a_arg_vals[o];
47649 LDKRouteHintHop a_arg_conv_14_conv;
47650 a_arg_conv_14_conv.inner = untag_ptr(a_arg_conv_14);
47651 a_arg_conv_14_conv.is_owned = ptr_is_owned(a_arg_conv_14);
47652 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
47653 a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
47654 a_arg_constr.data[o] = a_arg_conv_14_conv;
47657 LDKRouteHint ret_var = RouteHint_new(a_arg_constr);
47658 uint64_t ret_ref = 0;
47659 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47660 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47664 static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
47665 LDKRouteHint ret_var = RouteHint_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_RouteHint_clone_ptr"))) TS_RouteHint_clone_ptr(uint64_t arg) {
47672 LDKRouteHint 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 = RouteHint_clone_ptr(&arg_conv);
47681 uint64_t __attribute__((export_name("TS_RouteHint_clone"))) TS_RouteHint_clone(uint64_t orig) {
47682 LDKRouteHint 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 LDKRouteHint ret_var = RouteHint_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_RouteHint_hash"))) TS_RouteHint_hash(uint64_t o) {
47695 LDKRouteHint 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 = RouteHint_hash(&o_conv);
47704 jboolean __attribute__((export_name("TS_RouteHint_eq"))) TS_RouteHint_eq(uint64_t a, uint64_t b) {
47705 LDKRouteHint 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 LDKRouteHint 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 = RouteHint_eq(&a_conv, &b_conv);
47719 int8_tArray __attribute__((export_name("TS_RouteHint_write"))) TS_RouteHint_write(uint64_t obj) {
47720 LDKRouteHint obj_conv;
47721 obj_conv.inner = untag_ptr(obj);
47722 obj_conv.is_owned = ptr_is_owned(obj);
47723 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47724 obj_conv.is_owned = false;
47725 LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
47726 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47727 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47728 CVec_u8Z_free(ret_var);
47732 uint64_t __attribute__((export_name("TS_RouteHint_read"))) TS_RouteHint_read(int8_tArray ser) {
47733 LDKu8slice ser_ref;
47734 ser_ref.datalen = ser->arr_len;
47735 ser_ref.data = ser->elems;
47736 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
47737 *ret_conv = RouteHint_read(ser_ref);
47739 return tag_ptr(ret_conv, true);
47742 void __attribute__((export_name("TS_RouteHintHop_free"))) TS_RouteHintHop_free(uint64_t this_obj) {
47743 LDKRouteHintHop this_obj_conv;
47744 this_obj_conv.inner = untag_ptr(this_obj);
47745 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47747 RouteHintHop_free(this_obj_conv);
47750 int8_tArray __attribute__((export_name("TS_RouteHintHop_get_src_node_id"))) TS_RouteHintHop_get_src_node_id(uint64_t this_ptr) {
47751 LDKRouteHintHop this_ptr_conv;
47752 this_ptr_conv.inner = untag_ptr(this_ptr);
47753 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47755 this_ptr_conv.is_owned = false;
47756 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47757 memcpy(ret_arr->elems, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
47761 void __attribute__((export_name("TS_RouteHintHop_set_src_node_id"))) TS_RouteHintHop_set_src_node_id(uint64_t this_ptr, int8_tArray val) {
47762 LDKRouteHintHop this_ptr_conv;
47763 this_ptr_conv.inner = untag_ptr(this_ptr);
47764 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47766 this_ptr_conv.is_owned = false;
47767 LDKPublicKey val_ref;
47768 CHECK(val->arr_len == 33);
47769 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47770 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
47773 int64_t __attribute__((export_name("TS_RouteHintHop_get_short_channel_id"))) TS_RouteHintHop_get_short_channel_id(uint64_t this_ptr) {
47774 LDKRouteHintHop this_ptr_conv;
47775 this_ptr_conv.inner = untag_ptr(this_ptr);
47776 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47777 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47778 this_ptr_conv.is_owned = false;
47779 int64_t ret_conv = RouteHintHop_get_short_channel_id(&this_ptr_conv);
47783 void __attribute__((export_name("TS_RouteHintHop_set_short_channel_id"))) TS_RouteHintHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
47784 LDKRouteHintHop this_ptr_conv;
47785 this_ptr_conv.inner = untag_ptr(this_ptr);
47786 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47788 this_ptr_conv.is_owned = false;
47789 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
47792 uint64_t __attribute__((export_name("TS_RouteHintHop_get_fees"))) TS_RouteHintHop_get_fees(uint64_t this_ptr) {
47793 LDKRouteHintHop this_ptr_conv;
47794 this_ptr_conv.inner = untag_ptr(this_ptr);
47795 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47796 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47797 this_ptr_conv.is_owned = false;
47798 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
47799 uint64_t ret_ref = 0;
47800 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47801 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47805 void __attribute__((export_name("TS_RouteHintHop_set_fees"))) TS_RouteHintHop_set_fees(uint64_t this_ptr, uint64_t val) {
47806 LDKRouteHintHop this_ptr_conv;
47807 this_ptr_conv.inner = untag_ptr(this_ptr);
47808 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47810 this_ptr_conv.is_owned = false;
47811 LDKRoutingFees val_conv;
47812 val_conv.inner = untag_ptr(val);
47813 val_conv.is_owned = ptr_is_owned(val);
47814 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47815 val_conv = RoutingFees_clone(&val_conv);
47816 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
47819 int16_t __attribute__((export_name("TS_RouteHintHop_get_cltv_expiry_delta"))) TS_RouteHintHop_get_cltv_expiry_delta(uint64_t this_ptr) {
47820 LDKRouteHintHop this_ptr_conv;
47821 this_ptr_conv.inner = untag_ptr(this_ptr);
47822 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47824 this_ptr_conv.is_owned = false;
47825 int16_t ret_conv = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
47829 void __attribute__((export_name("TS_RouteHintHop_set_cltv_expiry_delta"))) TS_RouteHintHop_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
47830 LDKRouteHintHop this_ptr_conv;
47831 this_ptr_conv.inner = untag_ptr(this_ptr);
47832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47834 this_ptr_conv.is_owned = false;
47835 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
47838 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_minimum_msat"))) TS_RouteHintHop_get_htlc_minimum_msat(uint64_t this_ptr) {
47839 LDKRouteHintHop this_ptr_conv;
47840 this_ptr_conv.inner = untag_ptr(this_ptr);
47841 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47843 this_ptr_conv.is_owned = false;
47844 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47845 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
47846 uint64_t ret_ref = tag_ptr(ret_copy, true);
47850 void __attribute__((export_name("TS_RouteHintHop_set_htlc_minimum_msat"))) TS_RouteHintHop_set_htlc_minimum_msat(uint64_t this_ptr, uint64_t val) {
47851 LDKRouteHintHop this_ptr_conv;
47852 this_ptr_conv.inner = untag_ptr(this_ptr);
47853 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47854 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47855 this_ptr_conv.is_owned = false;
47856 void* val_ptr = untag_ptr(val);
47857 CHECK_ACCESS(val_ptr);
47858 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
47859 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
47860 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
47863 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_maximum_msat"))) TS_RouteHintHop_get_htlc_maximum_msat(uint64_t this_ptr) {
47864 LDKRouteHintHop this_ptr_conv;
47865 this_ptr_conv.inner = untag_ptr(this_ptr);
47866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47868 this_ptr_conv.is_owned = false;
47869 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47870 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
47871 uint64_t ret_ref = tag_ptr(ret_copy, true);
47875 void __attribute__((export_name("TS_RouteHintHop_set_htlc_maximum_msat"))) TS_RouteHintHop_set_htlc_maximum_msat(uint64_t this_ptr, uint64_t val) {
47876 LDKRouteHintHop this_ptr_conv;
47877 this_ptr_conv.inner = untag_ptr(this_ptr);
47878 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47879 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47880 this_ptr_conv.is_owned = false;
47881 void* val_ptr = untag_ptr(val);
47882 CHECK_ACCESS(val_ptr);
47883 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
47884 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
47885 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
47888 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) {
47889 LDKPublicKey src_node_id_arg_ref;
47890 CHECK(src_node_id_arg->arr_len == 33);
47891 memcpy(src_node_id_arg_ref.compressed_form, src_node_id_arg->elems, 33); FREE(src_node_id_arg);
47892 LDKRoutingFees fees_arg_conv;
47893 fees_arg_conv.inner = untag_ptr(fees_arg);
47894 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
47895 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
47896 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
47897 void* htlc_minimum_msat_arg_ptr = untag_ptr(htlc_minimum_msat_arg);
47898 CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
47899 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_minimum_msat_arg_ptr);
47900 htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_minimum_msat_arg));
47901 void* htlc_maximum_msat_arg_ptr = untag_ptr(htlc_maximum_msat_arg);
47902 CHECK_ACCESS(htlc_maximum_msat_arg_ptr);
47903 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_maximum_msat_arg_ptr);
47904 htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_maximum_msat_arg));
47905 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);
47906 uint64_t ret_ref = 0;
47907 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47908 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47912 static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
47913 LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
47914 uint64_t ret_ref = 0;
47915 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47916 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47919 int64_t __attribute__((export_name("TS_RouteHintHop_clone_ptr"))) TS_RouteHintHop_clone_ptr(uint64_t arg) {
47920 LDKRouteHintHop arg_conv;
47921 arg_conv.inner = untag_ptr(arg);
47922 arg_conv.is_owned = ptr_is_owned(arg);
47923 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47924 arg_conv.is_owned = false;
47925 int64_t ret_conv = RouteHintHop_clone_ptr(&arg_conv);
47929 uint64_t __attribute__((export_name("TS_RouteHintHop_clone"))) TS_RouteHintHop_clone(uint64_t orig) {
47930 LDKRouteHintHop orig_conv;
47931 orig_conv.inner = untag_ptr(orig);
47932 orig_conv.is_owned = ptr_is_owned(orig);
47933 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47934 orig_conv.is_owned = false;
47935 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
47936 uint64_t ret_ref = 0;
47937 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47938 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47942 int64_t __attribute__((export_name("TS_RouteHintHop_hash"))) TS_RouteHintHop_hash(uint64_t o) {
47943 LDKRouteHintHop o_conv;
47944 o_conv.inner = untag_ptr(o);
47945 o_conv.is_owned = ptr_is_owned(o);
47946 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47947 o_conv.is_owned = false;
47948 int64_t ret_conv = RouteHintHop_hash(&o_conv);
47952 jboolean __attribute__((export_name("TS_RouteHintHop_eq"))) TS_RouteHintHop_eq(uint64_t a, uint64_t b) {
47953 LDKRouteHintHop a_conv;
47954 a_conv.inner = untag_ptr(a);
47955 a_conv.is_owned = ptr_is_owned(a);
47956 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47957 a_conv.is_owned = false;
47958 LDKRouteHintHop b_conv;
47959 b_conv.inner = untag_ptr(b);
47960 b_conv.is_owned = ptr_is_owned(b);
47961 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47962 b_conv.is_owned = false;
47963 jboolean ret_conv = RouteHintHop_eq(&a_conv, &b_conv);
47967 int8_tArray __attribute__((export_name("TS_RouteHintHop_write"))) TS_RouteHintHop_write(uint64_t obj) {
47968 LDKRouteHintHop obj_conv;
47969 obj_conv.inner = untag_ptr(obj);
47970 obj_conv.is_owned = ptr_is_owned(obj);
47971 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47972 obj_conv.is_owned = false;
47973 LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
47974 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47975 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47976 CVec_u8Z_free(ret_var);
47980 uint64_t __attribute__((export_name("TS_RouteHintHop_read"))) TS_RouteHintHop_read(int8_tArray ser) {
47981 LDKu8slice ser_ref;
47982 ser_ref.datalen = ser->arr_len;
47983 ser_ref.data = ser->elems;
47984 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
47985 *ret_conv = RouteHintHop_read(ser_ref);
47987 return tag_ptr(ret_conv, true);
47990 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) {
47991 LDKPublicKey our_node_pubkey_ref;
47992 CHECK(our_node_pubkey->arr_len == 33);
47993 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
47994 LDKRouteParameters route_params_conv;
47995 route_params_conv.inner = untag_ptr(route_params);
47996 route_params_conv.is_owned = ptr_is_owned(route_params);
47997 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
47998 route_params_conv.is_owned = false;
47999 LDKNetworkGraph network_graph_conv;
48000 network_graph_conv.inner = untag_ptr(network_graph);
48001 network_graph_conv.is_owned = ptr_is_owned(network_graph);
48002 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
48003 network_graph_conv.is_owned = false;
48004 LDKCVec_ChannelDetailsZ first_hops_constr;
48005 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
48006 if (first_hops != 0) {
48007 first_hops_constr.datalen = first_hops->arr_len;
48008 if (first_hops_constr.datalen > 0)
48009 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
48011 first_hops_constr.data = NULL;
48012 uint64_t* first_hops_vals = first_hops->elems;
48013 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
48014 uint64_t first_hops_conv_16 = first_hops_vals[q];
48015 LDKChannelDetails first_hops_conv_16_conv;
48016 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
48017 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
48018 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
48019 first_hops_conv_16_conv.is_owned = false;
48020 first_hops_constr.data[q] = first_hops_conv_16_conv;
48023 first_hops_ptr = &first_hops_constr;
48025 void* logger_ptr = untag_ptr(logger);
48026 CHECK_ACCESS(logger_ptr);
48027 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48028 if (logger_conv.free == LDKLogger_JCalls_free) {
48029 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48030 LDKLogger_JCalls_cloned(&logger_conv);
48032 void* scorer_ptr = untag_ptr(scorer);
48033 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
48034 LDKScore* scorer_conv = (LDKScore*)scorer_ptr;
48035 uint8_t random_seed_bytes_arr[32];
48036 CHECK(random_seed_bytes->arr_len == 32);
48037 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
48038 uint8_t (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
48039 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
48040 *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);
48041 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
48042 return tag_ptr(ret_conv, true);
48045 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) {
48046 LDKPublicKey our_node_pubkey_ref;
48047 CHECK(our_node_pubkey->arr_len == 33);
48048 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
48049 LDKCVec_PublicKeyZ hops_constr;
48050 hops_constr.datalen = hops->arr_len;
48051 if (hops_constr.datalen > 0)
48052 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
48054 hops_constr.data = NULL;
48055 int8_tArray* hops_vals = (void*) hops->elems;
48056 for (size_t m = 0; m < hops_constr.datalen; m++) {
48057 int8_tArray hops_conv_12 = hops_vals[m];
48058 LDKPublicKey hops_conv_12_ref;
48059 CHECK(hops_conv_12->arr_len == 33);
48060 memcpy(hops_conv_12_ref.compressed_form, hops_conv_12->elems, 33); FREE(hops_conv_12);
48061 hops_constr.data[m] = hops_conv_12_ref;
48064 LDKRouteParameters route_params_conv;
48065 route_params_conv.inner = untag_ptr(route_params);
48066 route_params_conv.is_owned = ptr_is_owned(route_params);
48067 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
48068 route_params_conv.is_owned = false;
48069 LDKNetworkGraph network_graph_conv;
48070 network_graph_conv.inner = untag_ptr(network_graph);
48071 network_graph_conv.is_owned = ptr_is_owned(network_graph);
48072 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
48073 network_graph_conv.is_owned = false;
48074 void* logger_ptr = untag_ptr(logger);
48075 CHECK_ACCESS(logger_ptr);
48076 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48077 if (logger_conv.free == LDKLogger_JCalls_free) {
48078 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48079 LDKLogger_JCalls_cloned(&logger_conv);
48081 uint8_t random_seed_bytes_arr[32];
48082 CHECK(random_seed_bytes->arr_len == 32);
48083 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
48084 uint8_t (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
48085 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
48086 *ret_conv = build_route_from_hops(our_node_pubkey_ref, hops_constr, &route_params_conv, &network_graph_conv, logger_conv, random_seed_bytes_ref);
48087 return tag_ptr(ret_conv, true);
48090 void __attribute__((export_name("TS_Score_free"))) TS_Score_free(uint64_t this_ptr) {
48091 if (!ptr_is_owned(this_ptr)) return;
48092 void* this_ptr_ptr = untag_ptr(this_ptr);
48093 CHECK_ACCESS(this_ptr_ptr);
48094 LDKScore this_ptr_conv = *(LDKScore*)(this_ptr_ptr);
48095 FREE(untag_ptr(this_ptr));
48096 Score_free(this_ptr_conv);
48099 void __attribute__((export_name("TS_LockableScore_free"))) TS_LockableScore_free(uint64_t this_ptr) {
48100 if (!ptr_is_owned(this_ptr)) return;
48101 void* this_ptr_ptr = untag_ptr(this_ptr);
48102 CHECK_ACCESS(this_ptr_ptr);
48103 LDKLockableScore this_ptr_conv = *(LDKLockableScore*)(this_ptr_ptr);
48104 FREE(untag_ptr(this_ptr));
48105 LockableScore_free(this_ptr_conv);
48108 void __attribute__((export_name("TS_WriteableScore_free"))) TS_WriteableScore_free(uint64_t this_ptr) {
48109 if (!ptr_is_owned(this_ptr)) return;
48110 void* this_ptr_ptr = untag_ptr(this_ptr);
48111 CHECK_ACCESS(this_ptr_ptr);
48112 LDKWriteableScore this_ptr_conv = *(LDKWriteableScore*)(this_ptr_ptr);
48113 FREE(untag_ptr(this_ptr));
48114 WriteableScore_free(this_ptr_conv);
48117 void __attribute__((export_name("TS_MultiThreadedLockableScore_free"))) TS_MultiThreadedLockableScore_free(uint64_t this_obj) {
48118 LDKMultiThreadedLockableScore this_obj_conv;
48119 this_obj_conv.inner = untag_ptr(this_obj);
48120 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48122 MultiThreadedLockableScore_free(this_obj_conv);
48125 void __attribute__((export_name("TS_MultiThreadedScoreLock_free"))) TS_MultiThreadedScoreLock_free(uint64_t this_obj) {
48126 LDKMultiThreadedScoreLock this_obj_conv;
48127 this_obj_conv.inner = untag_ptr(this_obj);
48128 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48130 MultiThreadedScoreLock_free(this_obj_conv);
48133 uint64_t __attribute__((export_name("TS_MultiThreadedScoreLock_as_Score"))) TS_MultiThreadedScoreLock_as_Score(uint64_t this_arg) {
48134 LDKMultiThreadedScoreLock this_arg_conv;
48135 this_arg_conv.inner = untag_ptr(this_arg);
48136 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48137 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48138 this_arg_conv.is_owned = false;
48139 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
48140 *ret_ret = MultiThreadedScoreLock_as_Score(&this_arg_conv);
48141 return tag_ptr(ret_ret, true);
48144 int8_tArray __attribute__((export_name("TS_MultiThreadedScoreLock_write"))) TS_MultiThreadedScoreLock_write(uint64_t obj) {
48145 LDKMultiThreadedScoreLock obj_conv;
48146 obj_conv.inner = untag_ptr(obj);
48147 obj_conv.is_owned = ptr_is_owned(obj);
48148 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48149 obj_conv.is_owned = false;
48150 LDKCVec_u8Z ret_var = MultiThreadedScoreLock_write(&obj_conv);
48151 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48152 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48153 CVec_u8Z_free(ret_var);
48157 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_LockableScore"))) TS_MultiThreadedLockableScore_as_LockableScore(uint64_t this_arg) {
48158 LDKMultiThreadedLockableScore this_arg_conv;
48159 this_arg_conv.inner = untag_ptr(this_arg);
48160 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48162 this_arg_conv.is_owned = false;
48163 LDKLockableScore* ret_ret = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
48164 *ret_ret = MultiThreadedLockableScore_as_LockableScore(&this_arg_conv);
48165 return tag_ptr(ret_ret, true);
48168 int8_tArray __attribute__((export_name("TS_MultiThreadedLockableScore_write"))) TS_MultiThreadedLockableScore_write(uint64_t obj) {
48169 LDKMultiThreadedLockableScore obj_conv;
48170 obj_conv.inner = untag_ptr(obj);
48171 obj_conv.is_owned = ptr_is_owned(obj);
48172 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48173 obj_conv.is_owned = false;
48174 LDKCVec_u8Z ret_var = MultiThreadedLockableScore_write(&obj_conv);
48175 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48176 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48177 CVec_u8Z_free(ret_var);
48181 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_WriteableScore"))) TS_MultiThreadedLockableScore_as_WriteableScore(uint64_t this_arg) {
48182 LDKMultiThreadedLockableScore this_arg_conv;
48183 this_arg_conv.inner = untag_ptr(this_arg);
48184 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48186 this_arg_conv.is_owned = false;
48187 LDKWriteableScore* ret_ret = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
48188 *ret_ret = MultiThreadedLockableScore_as_WriteableScore(&this_arg_conv);
48189 return tag_ptr(ret_ret, true);
48192 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_new"))) TS_MultiThreadedLockableScore_new(uint64_t score) {
48193 void* score_ptr = untag_ptr(score);
48194 CHECK_ACCESS(score_ptr);
48195 LDKScore score_conv = *(LDKScore*)(score_ptr);
48196 if (score_conv.free == LDKScore_JCalls_free) {
48197 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48198 LDKScore_JCalls_cloned(&score_conv);
48200 LDKMultiThreadedLockableScore ret_var = MultiThreadedLockableScore_new(score_conv);
48201 uint64_t ret_ref = 0;
48202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48207 void __attribute__((export_name("TS_ChannelUsage_free"))) TS_ChannelUsage_free(uint64_t this_obj) {
48208 LDKChannelUsage this_obj_conv;
48209 this_obj_conv.inner = untag_ptr(this_obj);
48210 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48212 ChannelUsage_free(this_obj_conv);
48215 int64_t __attribute__((export_name("TS_ChannelUsage_get_amount_msat"))) TS_ChannelUsage_get_amount_msat(uint64_t this_ptr) {
48216 LDKChannelUsage this_ptr_conv;
48217 this_ptr_conv.inner = untag_ptr(this_ptr);
48218 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48220 this_ptr_conv.is_owned = false;
48221 int64_t ret_conv = ChannelUsage_get_amount_msat(&this_ptr_conv);
48225 void __attribute__((export_name("TS_ChannelUsage_set_amount_msat"))) TS_ChannelUsage_set_amount_msat(uint64_t this_ptr, int64_t val) {
48226 LDKChannelUsage this_ptr_conv;
48227 this_ptr_conv.inner = untag_ptr(this_ptr);
48228 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48230 this_ptr_conv.is_owned = false;
48231 ChannelUsage_set_amount_msat(&this_ptr_conv, val);
48234 int64_t __attribute__((export_name("TS_ChannelUsage_get_inflight_htlc_msat"))) TS_ChannelUsage_get_inflight_htlc_msat(uint64_t this_ptr) {
48235 LDKChannelUsage this_ptr_conv;
48236 this_ptr_conv.inner = untag_ptr(this_ptr);
48237 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48238 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48239 this_ptr_conv.is_owned = false;
48240 int64_t ret_conv = ChannelUsage_get_inflight_htlc_msat(&this_ptr_conv);
48244 void __attribute__((export_name("TS_ChannelUsage_set_inflight_htlc_msat"))) TS_ChannelUsage_set_inflight_htlc_msat(uint64_t this_ptr, int64_t val) {
48245 LDKChannelUsage this_ptr_conv;
48246 this_ptr_conv.inner = untag_ptr(this_ptr);
48247 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48249 this_ptr_conv.is_owned = false;
48250 ChannelUsage_set_inflight_htlc_msat(&this_ptr_conv, val);
48253 uint64_t __attribute__((export_name("TS_ChannelUsage_get_effective_capacity"))) TS_ChannelUsage_get_effective_capacity(uint64_t this_ptr) {
48254 LDKChannelUsage this_ptr_conv;
48255 this_ptr_conv.inner = untag_ptr(this_ptr);
48256 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48258 this_ptr_conv.is_owned = false;
48259 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
48260 *ret_copy = ChannelUsage_get_effective_capacity(&this_ptr_conv);
48261 uint64_t ret_ref = tag_ptr(ret_copy, true);
48265 void __attribute__((export_name("TS_ChannelUsage_set_effective_capacity"))) TS_ChannelUsage_set_effective_capacity(uint64_t this_ptr, uint64_t val) {
48266 LDKChannelUsage this_ptr_conv;
48267 this_ptr_conv.inner = untag_ptr(this_ptr);
48268 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48270 this_ptr_conv.is_owned = false;
48271 void* val_ptr = untag_ptr(val);
48272 CHECK_ACCESS(val_ptr);
48273 LDKEffectiveCapacity val_conv = *(LDKEffectiveCapacity*)(val_ptr);
48274 val_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(val));
48275 ChannelUsage_set_effective_capacity(&this_ptr_conv, val_conv);
48278 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) {
48279 void* effective_capacity_arg_ptr = untag_ptr(effective_capacity_arg);
48280 CHECK_ACCESS(effective_capacity_arg_ptr);
48281 LDKEffectiveCapacity effective_capacity_arg_conv = *(LDKEffectiveCapacity*)(effective_capacity_arg_ptr);
48282 effective_capacity_arg_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(effective_capacity_arg));
48283 LDKChannelUsage ret_var = ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg_conv);
48284 uint64_t ret_ref = 0;
48285 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48286 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48290 static inline uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg) {
48291 LDKChannelUsage ret_var = ChannelUsage_clone(arg);
48292 uint64_t ret_ref = 0;
48293 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48294 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48297 int64_t __attribute__((export_name("TS_ChannelUsage_clone_ptr"))) TS_ChannelUsage_clone_ptr(uint64_t arg) {
48298 LDKChannelUsage arg_conv;
48299 arg_conv.inner = untag_ptr(arg);
48300 arg_conv.is_owned = ptr_is_owned(arg);
48301 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48302 arg_conv.is_owned = false;
48303 int64_t ret_conv = ChannelUsage_clone_ptr(&arg_conv);
48307 uint64_t __attribute__((export_name("TS_ChannelUsage_clone"))) TS_ChannelUsage_clone(uint64_t orig) {
48308 LDKChannelUsage orig_conv;
48309 orig_conv.inner = untag_ptr(orig);
48310 orig_conv.is_owned = ptr_is_owned(orig);
48311 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48312 orig_conv.is_owned = false;
48313 LDKChannelUsage ret_var = ChannelUsage_clone(&orig_conv);
48314 uint64_t ret_ref = 0;
48315 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48316 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48320 void __attribute__((export_name("TS_FixedPenaltyScorer_free"))) TS_FixedPenaltyScorer_free(uint64_t this_obj) {
48321 LDKFixedPenaltyScorer this_obj_conv;
48322 this_obj_conv.inner = untag_ptr(this_obj);
48323 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48325 FixedPenaltyScorer_free(this_obj_conv);
48328 static inline uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg) {
48329 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(arg);
48330 uint64_t ret_ref = 0;
48331 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48332 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48335 int64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone_ptr"))) TS_FixedPenaltyScorer_clone_ptr(uint64_t arg) {
48336 LDKFixedPenaltyScorer arg_conv;
48337 arg_conv.inner = untag_ptr(arg);
48338 arg_conv.is_owned = ptr_is_owned(arg);
48339 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48340 arg_conv.is_owned = false;
48341 int64_t ret_conv = FixedPenaltyScorer_clone_ptr(&arg_conv);
48345 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone"))) TS_FixedPenaltyScorer_clone(uint64_t orig) {
48346 LDKFixedPenaltyScorer orig_conv;
48347 orig_conv.inner = untag_ptr(orig);
48348 orig_conv.is_owned = ptr_is_owned(orig);
48349 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48350 orig_conv.is_owned = false;
48351 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(&orig_conv);
48352 uint64_t ret_ref = 0;
48353 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48354 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48358 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_with_penalty"))) TS_FixedPenaltyScorer_with_penalty(int64_t penalty_msat) {
48359 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_with_penalty(penalty_msat);
48360 uint64_t ret_ref = 0;
48361 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48362 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48366 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_as_Score"))) TS_FixedPenaltyScorer_as_Score(uint64_t this_arg) {
48367 LDKFixedPenaltyScorer this_arg_conv;
48368 this_arg_conv.inner = untag_ptr(this_arg);
48369 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48371 this_arg_conv.is_owned = false;
48372 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
48373 *ret_ret = FixedPenaltyScorer_as_Score(&this_arg_conv);
48374 return tag_ptr(ret_ret, true);
48377 int8_tArray __attribute__((export_name("TS_FixedPenaltyScorer_write"))) TS_FixedPenaltyScorer_write(uint64_t obj) {
48378 LDKFixedPenaltyScorer obj_conv;
48379 obj_conv.inner = untag_ptr(obj);
48380 obj_conv.is_owned = ptr_is_owned(obj);
48381 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48382 obj_conv.is_owned = false;
48383 LDKCVec_u8Z ret_var = FixedPenaltyScorer_write(&obj_conv);
48384 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48385 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48386 CVec_u8Z_free(ret_var);
48390 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_read"))) TS_FixedPenaltyScorer_read(int8_tArray ser, int64_t arg) {
48391 LDKu8slice ser_ref;
48392 ser_ref.datalen = ser->arr_len;
48393 ser_ref.data = ser->elems;
48394 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
48395 *ret_conv = FixedPenaltyScorer_read(ser_ref, arg);
48397 return tag_ptr(ret_conv, true);
48400 void __attribute__((export_name("TS_ProbabilisticScorer_free"))) TS_ProbabilisticScorer_free(uint64_t this_obj) {
48401 LDKProbabilisticScorer this_obj_conv;
48402 this_obj_conv.inner = untag_ptr(this_obj);
48403 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48404 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48405 ProbabilisticScorer_free(this_obj_conv);
48408 void __attribute__((export_name("TS_ProbabilisticScoringParameters_free"))) TS_ProbabilisticScoringParameters_free(uint64_t this_obj) {
48409 LDKProbabilisticScoringParameters this_obj_conv;
48410 this_obj_conv.inner = untag_ptr(this_obj);
48411 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48412 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48413 ProbabilisticScoringParameters_free(this_obj_conv);
48416 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_base_penalty_msat"))) TS_ProbabilisticScoringParameters_get_base_penalty_msat(uint64_t this_ptr) {
48417 LDKProbabilisticScoringParameters this_ptr_conv;
48418 this_ptr_conv.inner = untag_ptr(this_ptr);
48419 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48420 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48421 this_ptr_conv.is_owned = false;
48422 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_msat(&this_ptr_conv);
48426 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_base_penalty_msat"))) TS_ProbabilisticScoringParameters_set_base_penalty_msat(uint64_t this_ptr, int64_t val) {
48427 LDKProbabilisticScoringParameters this_ptr_conv;
48428 this_ptr_conv.inner = untag_ptr(this_ptr);
48429 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48430 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48431 this_ptr_conv.is_owned = false;
48432 ProbabilisticScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
48435 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) {
48436 LDKProbabilisticScoringParameters this_ptr_conv;
48437 this_ptr_conv.inner = untag_ptr(this_ptr);
48438 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48439 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48440 this_ptr_conv.is_owned = false;
48441 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(&this_ptr_conv);
48445 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) {
48446 LDKProbabilisticScoringParameters this_ptr_conv;
48447 this_ptr_conv.inner = untag_ptr(this_ptr);
48448 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48450 this_ptr_conv.is_owned = false;
48451 ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(&this_ptr_conv, val);
48454 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(uint64_t this_ptr) {
48455 LDKProbabilisticScoringParameters this_ptr_conv;
48456 this_ptr_conv.inner = untag_ptr(this_ptr);
48457 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48459 this_ptr_conv.is_owned = false;
48460 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(&this_ptr_conv);
48464 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) {
48465 LDKProbabilisticScoringParameters this_ptr_conv;
48466 this_ptr_conv.inner = untag_ptr(this_ptr);
48467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48469 this_ptr_conv.is_owned = false;
48470 ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
48473 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life"))) TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(uint64_t this_ptr) {
48474 LDKProbabilisticScoringParameters this_ptr_conv;
48475 this_ptr_conv.inner = untag_ptr(this_ptr);
48476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48478 this_ptr_conv.is_owned = false;
48479 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_offset_half_life(&this_ptr_conv);
48483 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) {
48484 LDKProbabilisticScoringParameters this_ptr_conv;
48485 this_ptr_conv.inner = untag_ptr(this_ptr);
48486 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48488 this_ptr_conv.is_owned = false;
48489 ProbabilisticScoringParameters_set_liquidity_offset_half_life(&this_ptr_conv, val);
48492 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) {
48493 LDKProbabilisticScoringParameters this_ptr_conv;
48494 this_ptr_conv.inner = untag_ptr(this_ptr);
48495 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48497 this_ptr_conv.is_owned = false;
48498 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
48502 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) {
48503 LDKProbabilisticScoringParameters this_ptr_conv;
48504 this_ptr_conv.inner = untag_ptr(this_ptr);
48505 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48507 this_ptr_conv.is_owned = false;
48508 ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
48511 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) {
48512 LDKProbabilisticScoringParameters this_ptr_conv;
48513 this_ptr_conv.inner = untag_ptr(this_ptr);
48514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48516 this_ptr_conv.is_owned = false;
48517 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv);
48521 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) {
48522 LDKProbabilisticScoringParameters this_ptr_conv;
48523 this_ptr_conv.inner = untag_ptr(this_ptr);
48524 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48526 this_ptr_conv.is_owned = false;
48527 ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
48530 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) {
48531 LDKProbabilisticScoringParameters this_ptr_conv;
48532 this_ptr_conv.inner = untag_ptr(this_ptr);
48533 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48535 this_ptr_conv.is_owned = false;
48536 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
48540 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) {
48541 LDKProbabilisticScoringParameters this_ptr_conv;
48542 this_ptr_conv.inner = untag_ptr(this_ptr);
48543 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48545 this_ptr_conv.is_owned = false;
48546 ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
48549 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) {
48550 LDKProbabilisticScoringParameters this_ptr_conv;
48551 this_ptr_conv.inner = untag_ptr(this_ptr);
48552 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48554 this_ptr_conv.is_owned = false;
48555 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_no_updates_half_life(&this_ptr_conv);
48559 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) {
48560 LDKProbabilisticScoringParameters this_ptr_conv;
48561 this_ptr_conv.inner = untag_ptr(this_ptr);
48562 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48563 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48564 this_ptr_conv.is_owned = false;
48565 ProbabilisticScoringParameters_set_historical_no_updates_half_life(&this_ptr_conv, val);
48568 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat"))) TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(uint64_t this_ptr) {
48569 LDKProbabilisticScoringParameters this_ptr_conv;
48570 this_ptr_conv.inner = untag_ptr(this_ptr);
48571 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48573 this_ptr_conv.is_owned = false;
48574 int64_t ret_conv = ProbabilisticScoringParameters_get_anti_probing_penalty_msat(&this_ptr_conv);
48578 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) {
48579 LDKProbabilisticScoringParameters this_ptr_conv;
48580 this_ptr_conv.inner = untag_ptr(this_ptr);
48581 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48582 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48583 this_ptr_conv.is_owned = false;
48584 ProbabilisticScoringParameters_set_anti_probing_penalty_msat(&this_ptr_conv, val);
48587 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(uint64_t this_ptr) {
48588 LDKProbabilisticScoringParameters this_ptr_conv;
48589 this_ptr_conv.inner = untag_ptr(this_ptr);
48590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48592 this_ptr_conv.is_owned = false;
48593 int64_t ret_conv = ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(&this_ptr_conv);
48597 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) {
48598 LDKProbabilisticScoringParameters this_ptr_conv;
48599 this_ptr_conv.inner = untag_ptr(this_ptr);
48600 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48602 this_ptr_conv.is_owned = false;
48603 ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(&this_ptr_conv, val);
48606 static inline uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg) {
48607 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(arg);
48608 uint64_t ret_ref = 0;
48609 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48610 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48613 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone_ptr"))) TS_ProbabilisticScoringParameters_clone_ptr(uint64_t arg) {
48614 LDKProbabilisticScoringParameters arg_conv;
48615 arg_conv.inner = untag_ptr(arg);
48616 arg_conv.is_owned = ptr_is_owned(arg);
48617 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48618 arg_conv.is_owned = false;
48619 int64_t ret_conv = ProbabilisticScoringParameters_clone_ptr(&arg_conv);
48623 uint64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone"))) TS_ProbabilisticScoringParameters_clone(uint64_t orig) {
48624 LDKProbabilisticScoringParameters orig_conv;
48625 orig_conv.inner = untag_ptr(orig);
48626 orig_conv.is_owned = ptr_is_owned(orig);
48627 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48628 orig_conv.is_owned = false;
48629 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(&orig_conv);
48630 uint64_t ret_ref = 0;
48631 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48632 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48636 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_new"))) TS_ProbabilisticScorer_new(uint64_t params, uint64_t network_graph, uint64_t logger) {
48637 LDKProbabilisticScoringParameters params_conv;
48638 params_conv.inner = untag_ptr(params);
48639 params_conv.is_owned = ptr_is_owned(params);
48640 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
48641 params_conv = ProbabilisticScoringParameters_clone(¶ms_conv);
48642 LDKNetworkGraph network_graph_conv;
48643 network_graph_conv.inner = untag_ptr(network_graph);
48644 network_graph_conv.is_owned = ptr_is_owned(network_graph);
48645 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
48646 network_graph_conv.is_owned = false;
48647 void* logger_ptr = untag_ptr(logger);
48648 CHECK_ACCESS(logger_ptr);
48649 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48650 if (logger_conv.free == LDKLogger_JCalls_free) {
48651 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48652 LDKLogger_JCalls_cloned(&logger_conv);
48654 LDKProbabilisticScorer ret_var = ProbabilisticScorer_new(params_conv, &network_graph_conv, logger_conv);
48655 uint64_t ret_ref = 0;
48656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48657 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48661 void __attribute__((export_name("TS_ProbabilisticScorer_debug_log_liquidity_stats"))) TS_ProbabilisticScorer_debug_log_liquidity_stats(uint64_t this_arg) {
48662 LDKProbabilisticScorer this_arg_conv;
48663 this_arg_conv.inner = untag_ptr(this_arg);
48664 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48666 this_arg_conv.is_owned = false;
48667 ProbabilisticScorer_debug_log_liquidity_stats(&this_arg_conv);
48670 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) {
48671 LDKProbabilisticScorer this_arg_conv;
48672 this_arg_conv.inner = untag_ptr(this_arg);
48673 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48675 this_arg_conv.is_owned = false;
48676 LDKNodeId target_conv;
48677 target_conv.inner = untag_ptr(target);
48678 target_conv.is_owned = ptr_is_owned(target);
48679 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
48680 target_conv.is_owned = false;
48681 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
48682 *ret_copy = ProbabilisticScorer_estimated_channel_liquidity_range(&this_arg_conv, scid, &target_conv);
48683 uint64_t ret_ref = tag_ptr(ret_copy, true);
48687 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities"))) TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(uint64_t this_arg, int64_t scid, uint64_t target) {
48688 LDKProbabilisticScorer this_arg_conv;
48689 this_arg_conv.inner = untag_ptr(this_arg);
48690 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48692 this_arg_conv.is_owned = false;
48693 LDKNodeId target_conv;
48694 target_conv.inner = untag_ptr(target);
48695 target_conv.is_owned = ptr_is_owned(target);
48696 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
48697 target_conv.is_owned = false;
48698 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
48699 *ret_copy = ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(&this_arg_conv, scid, &target_conv);
48700 uint64_t ret_ref = tag_ptr(ret_copy, true);
48704 void __attribute__((export_name("TS_ProbabilisticScorer_add_banned"))) TS_ProbabilisticScorer_add_banned(uint64_t this_arg, uint64_t node_id) {
48705 LDKProbabilisticScorer this_arg_conv;
48706 this_arg_conv.inner = untag_ptr(this_arg);
48707 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48708 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48709 this_arg_conv.is_owned = false;
48710 LDKNodeId node_id_conv;
48711 node_id_conv.inner = untag_ptr(node_id);
48712 node_id_conv.is_owned = ptr_is_owned(node_id);
48713 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48714 node_id_conv.is_owned = false;
48715 ProbabilisticScorer_add_banned(&this_arg_conv, &node_id_conv);
48718 void __attribute__((export_name("TS_ProbabilisticScorer_remove_banned"))) TS_ProbabilisticScorer_remove_banned(uint64_t this_arg, uint64_t node_id) {
48719 LDKProbabilisticScorer this_arg_conv;
48720 this_arg_conv.inner = untag_ptr(this_arg);
48721 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48723 this_arg_conv.is_owned = false;
48724 LDKNodeId node_id_conv;
48725 node_id_conv.inner = untag_ptr(node_id);
48726 node_id_conv.is_owned = ptr_is_owned(node_id);
48727 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48728 node_id_conv.is_owned = false;
48729 ProbabilisticScorer_remove_banned(&this_arg_conv, &node_id_conv);
48732 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) {
48733 LDKProbabilisticScorer this_arg_conv;
48734 this_arg_conv.inner = untag_ptr(this_arg);
48735 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48737 this_arg_conv.is_owned = false;
48738 LDKNodeId node_id_conv;
48739 node_id_conv.inner = untag_ptr(node_id);
48740 node_id_conv.is_owned = ptr_is_owned(node_id);
48741 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48742 node_id_conv.is_owned = false;
48743 ProbabilisticScorer_set_manual_penalty(&this_arg_conv, &node_id_conv, penalty);
48746 void __attribute__((export_name("TS_ProbabilisticScorer_remove_manual_penalty"))) TS_ProbabilisticScorer_remove_manual_penalty(uint64_t this_arg, uint64_t node_id) {
48747 LDKProbabilisticScorer 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 LDKNodeId node_id_conv;
48753 node_id_conv.inner = untag_ptr(node_id);
48754 node_id_conv.is_owned = ptr_is_owned(node_id);
48755 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48756 node_id_conv.is_owned = false;
48757 ProbabilisticScorer_remove_manual_penalty(&this_arg_conv, &node_id_conv);
48760 void __attribute__((export_name("TS_ProbabilisticScorer_clear_manual_penalties"))) TS_ProbabilisticScorer_clear_manual_penalties(uint64_t this_arg) {
48761 LDKProbabilisticScorer this_arg_conv;
48762 this_arg_conv.inner = untag_ptr(this_arg);
48763 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48764 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48765 this_arg_conv.is_owned = false;
48766 ProbabilisticScorer_clear_manual_penalties(&this_arg_conv);
48769 void __attribute__((export_name("TS_ProbabilisticScoringParameters_add_banned_from_list"))) TS_ProbabilisticScoringParameters_add_banned_from_list(uint64_t this_arg, uint64_tArray node_ids) {
48770 LDKProbabilisticScoringParameters this_arg_conv;
48771 this_arg_conv.inner = untag_ptr(this_arg);
48772 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48774 this_arg_conv.is_owned = false;
48775 LDKCVec_NodeIdZ node_ids_constr;
48776 node_ids_constr.datalen = node_ids->arr_len;
48777 if (node_ids_constr.datalen > 0)
48778 node_ids_constr.data = MALLOC(node_ids_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
48780 node_ids_constr.data = NULL;
48781 uint64_t* node_ids_vals = node_ids->elems;
48782 for (size_t i = 0; i < node_ids_constr.datalen; i++) {
48783 uint64_t node_ids_conv_8 = node_ids_vals[i];
48784 LDKNodeId node_ids_conv_8_conv;
48785 node_ids_conv_8_conv.inner = untag_ptr(node_ids_conv_8);
48786 node_ids_conv_8_conv.is_owned = ptr_is_owned(node_ids_conv_8);
48787 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_ids_conv_8_conv);
48788 node_ids_conv_8_conv = NodeId_clone(&node_ids_conv_8_conv);
48789 node_ids_constr.data[i] = node_ids_conv_8_conv;
48792 ProbabilisticScoringParameters_add_banned_from_list(&this_arg_conv, node_ids_constr);
48795 uint64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_default"))) TS_ProbabilisticScoringParameters_default() {
48796 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_default();
48797 uint64_t ret_ref = 0;
48798 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48799 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48803 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_as_Score"))) TS_ProbabilisticScorer_as_Score(uint64_t this_arg) {
48804 LDKProbabilisticScorer this_arg_conv;
48805 this_arg_conv.inner = untag_ptr(this_arg);
48806 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48808 this_arg_conv.is_owned = false;
48809 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
48810 *ret_ret = ProbabilisticScorer_as_Score(&this_arg_conv);
48811 return tag_ptr(ret_ret, true);
48814 int8_tArray __attribute__((export_name("TS_ProbabilisticScorer_write"))) TS_ProbabilisticScorer_write(uint64_t obj) {
48815 LDKProbabilisticScorer obj_conv;
48816 obj_conv.inner = untag_ptr(obj);
48817 obj_conv.is_owned = ptr_is_owned(obj);
48818 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48819 obj_conv.is_owned = false;
48820 LDKCVec_u8Z ret_var = ProbabilisticScorer_write(&obj_conv);
48821 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48822 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48823 CVec_u8Z_free(ret_var);
48827 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) {
48828 LDKu8slice ser_ref;
48829 ser_ref.datalen = ser->arr_len;
48830 ser_ref.data = ser->elems;
48831 LDKProbabilisticScoringParameters arg_a_conv;
48832 arg_a_conv.inner = untag_ptr(arg_a);
48833 arg_a_conv.is_owned = ptr_is_owned(arg_a);
48834 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_a_conv);
48835 arg_a_conv = ProbabilisticScoringParameters_clone(&arg_a_conv);
48836 LDKNetworkGraph arg_b_conv;
48837 arg_b_conv.inner = untag_ptr(arg_b);
48838 arg_b_conv.is_owned = ptr_is_owned(arg_b);
48839 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_b_conv);
48840 arg_b_conv.is_owned = false;
48841 void* arg_c_ptr = untag_ptr(arg_c);
48842 CHECK_ACCESS(arg_c_ptr);
48843 LDKLogger arg_c_conv = *(LDKLogger*)(arg_c_ptr);
48844 if (arg_c_conv.free == LDKLogger_JCalls_free) {
48845 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48846 LDKLogger_JCalls_cloned(&arg_c_conv);
48848 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
48849 *ret_conv = ProbabilisticScorer_read(ser_ref, arg_a_conv, &arg_b_conv, arg_c_conv);
48851 return tag_ptr(ret_conv, true);
48854 void __attribute__((export_name("TS_OnionMessenger_free"))) TS_OnionMessenger_free(uint64_t this_obj) {
48855 LDKOnionMessenger this_obj_conv;
48856 this_obj_conv.inner = untag_ptr(this_obj);
48857 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48858 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48859 OnionMessenger_free(this_obj_conv);
48862 void __attribute__((export_name("TS_Destination_free"))) TS_Destination_free(uint64_t this_ptr) {
48863 if (!ptr_is_owned(this_ptr)) return;
48864 void* this_ptr_ptr = untag_ptr(this_ptr);
48865 CHECK_ACCESS(this_ptr_ptr);
48866 LDKDestination this_ptr_conv = *(LDKDestination*)(this_ptr_ptr);
48867 FREE(untag_ptr(this_ptr));
48868 Destination_free(this_ptr_conv);
48871 static inline uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg) {
48872 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48873 *ret_copy = Destination_clone(arg);
48874 uint64_t ret_ref = tag_ptr(ret_copy, true);
48877 int64_t __attribute__((export_name("TS_Destination_clone_ptr"))) TS_Destination_clone_ptr(uint64_t arg) {
48878 LDKDestination* arg_conv = (LDKDestination*)untag_ptr(arg);
48879 int64_t ret_conv = Destination_clone_ptr(arg_conv);
48883 uint64_t __attribute__((export_name("TS_Destination_clone"))) TS_Destination_clone(uint64_t orig) {
48884 LDKDestination* orig_conv = (LDKDestination*)untag_ptr(orig);
48885 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48886 *ret_copy = Destination_clone(orig_conv);
48887 uint64_t ret_ref = tag_ptr(ret_copy, true);
48891 uint64_t __attribute__((export_name("TS_Destination_node"))) TS_Destination_node(int8_tArray a) {
48892 LDKPublicKey a_ref;
48893 CHECK(a->arr_len == 33);
48894 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
48895 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48896 *ret_copy = Destination_node(a_ref);
48897 uint64_t ret_ref = tag_ptr(ret_copy, true);
48901 uint64_t __attribute__((export_name("TS_Destination_blinded_path"))) TS_Destination_blinded_path(uint64_t a) {
48902 LDKBlindedPath a_conv;
48903 a_conv.inner = untag_ptr(a);
48904 a_conv.is_owned = ptr_is_owned(a);
48905 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
48906 a_conv = BlindedPath_clone(&a_conv);
48907 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48908 *ret_copy = Destination_blinded_path(a_conv);
48909 uint64_t ret_ref = tag_ptr(ret_copy, true);
48913 void __attribute__((export_name("TS_SendError_free"))) TS_SendError_free(uint64_t this_ptr) {
48914 if (!ptr_is_owned(this_ptr)) return;
48915 void* this_ptr_ptr = untag_ptr(this_ptr);
48916 CHECK_ACCESS(this_ptr_ptr);
48917 LDKSendError this_ptr_conv = *(LDKSendError*)(this_ptr_ptr);
48918 FREE(untag_ptr(this_ptr));
48919 SendError_free(this_ptr_conv);
48922 static inline uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg) {
48923 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48924 *ret_copy = SendError_clone(arg);
48925 uint64_t ret_ref = tag_ptr(ret_copy, true);
48928 int64_t __attribute__((export_name("TS_SendError_clone_ptr"))) TS_SendError_clone_ptr(uint64_t arg) {
48929 LDKSendError* arg_conv = (LDKSendError*)untag_ptr(arg);
48930 int64_t ret_conv = SendError_clone_ptr(arg_conv);
48934 uint64_t __attribute__((export_name("TS_SendError_clone"))) TS_SendError_clone(uint64_t orig) {
48935 LDKSendError* orig_conv = (LDKSendError*)untag_ptr(orig);
48936 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48937 *ret_copy = SendError_clone(orig_conv);
48938 uint64_t ret_ref = tag_ptr(ret_copy, true);
48942 uint64_t __attribute__((export_name("TS_SendError_secp256k1"))) TS_SendError_secp256k1(uint32_t a) {
48943 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
48944 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48945 *ret_copy = SendError_secp256k1(a_conv);
48946 uint64_t ret_ref = tag_ptr(ret_copy, true);
48950 uint64_t __attribute__((export_name("TS_SendError_too_big_packet"))) TS_SendError_too_big_packet() {
48951 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48952 *ret_copy = SendError_too_big_packet();
48953 uint64_t ret_ref = tag_ptr(ret_copy, true);
48957 uint64_t __attribute__((export_name("TS_SendError_too_few_blinded_hops"))) TS_SendError_too_few_blinded_hops() {
48958 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48959 *ret_copy = SendError_too_few_blinded_hops();
48960 uint64_t ret_ref = tag_ptr(ret_copy, true);
48964 uint64_t __attribute__((export_name("TS_SendError_invalid_first_hop"))) TS_SendError_invalid_first_hop() {
48965 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48966 *ret_copy = SendError_invalid_first_hop();
48967 uint64_t ret_ref = tag_ptr(ret_copy, true);
48971 uint64_t __attribute__((export_name("TS_SendError_invalid_message"))) TS_SendError_invalid_message() {
48972 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48973 *ret_copy = SendError_invalid_message();
48974 uint64_t ret_ref = tag_ptr(ret_copy, true);
48978 uint64_t __attribute__((export_name("TS_SendError_buffer_full"))) TS_SendError_buffer_full() {
48979 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48980 *ret_copy = SendError_buffer_full();
48981 uint64_t ret_ref = tag_ptr(ret_copy, true);
48985 uint64_t __attribute__((export_name("TS_SendError_get_node_id_failed"))) TS_SendError_get_node_id_failed() {
48986 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48987 *ret_copy = SendError_get_node_id_failed();
48988 uint64_t ret_ref = tag_ptr(ret_copy, true);
48992 uint64_t __attribute__((export_name("TS_SendError_blinded_path_advance_failed"))) TS_SendError_blinded_path_advance_failed() {
48993 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48994 *ret_copy = SendError_blinded_path_advance_failed();
48995 uint64_t ret_ref = tag_ptr(ret_copy, true);
48999 jboolean __attribute__((export_name("TS_SendError_eq"))) TS_SendError_eq(uint64_t a, uint64_t b) {
49000 LDKSendError* a_conv = (LDKSendError*)untag_ptr(a);
49001 LDKSendError* b_conv = (LDKSendError*)untag_ptr(b);
49002 jboolean ret_conv = SendError_eq(a_conv, b_conv);
49006 void __attribute__((export_name("TS_CustomOnionMessageHandler_free"))) TS_CustomOnionMessageHandler_free(uint64_t this_ptr) {
49007 if (!ptr_is_owned(this_ptr)) return;
49008 void* this_ptr_ptr = untag_ptr(this_ptr);
49009 CHECK_ACCESS(this_ptr_ptr);
49010 LDKCustomOnionMessageHandler this_ptr_conv = *(LDKCustomOnionMessageHandler*)(this_ptr_ptr);
49011 FREE(untag_ptr(this_ptr));
49012 CustomOnionMessageHandler_free(this_ptr_conv);
49015 uint64_t __attribute__((export_name("TS_OnionMessenger_new"))) TS_OnionMessenger_new(uint64_t entropy_source, uint64_t node_signer, uint64_t logger, uint64_t custom_handler) {
49016 void* entropy_source_ptr = untag_ptr(entropy_source);
49017 CHECK_ACCESS(entropy_source_ptr);
49018 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
49019 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
49020 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49021 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
49023 void* node_signer_ptr = untag_ptr(node_signer);
49024 CHECK_ACCESS(node_signer_ptr);
49025 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
49026 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
49027 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49028 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
49030 void* logger_ptr = untag_ptr(logger);
49031 CHECK_ACCESS(logger_ptr);
49032 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
49033 if (logger_conv.free == LDKLogger_JCalls_free) {
49034 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49035 LDKLogger_JCalls_cloned(&logger_conv);
49037 void* custom_handler_ptr = untag_ptr(custom_handler);
49038 CHECK_ACCESS(custom_handler_ptr);
49039 LDKCustomOnionMessageHandler custom_handler_conv = *(LDKCustomOnionMessageHandler*)(custom_handler_ptr);
49040 if (custom_handler_conv.free == LDKCustomOnionMessageHandler_JCalls_free) {
49041 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49042 LDKCustomOnionMessageHandler_JCalls_cloned(&custom_handler_conv);
49044 LDKOnionMessenger ret_var = OnionMessenger_new(entropy_source_conv, node_signer_conv, logger_conv, custom_handler_conv);
49045 uint64_t ret_ref = 0;
49046 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49047 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49051 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) {
49052 LDKOnionMessenger this_arg_conv;
49053 this_arg_conv.inner = untag_ptr(this_arg);
49054 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49056 this_arg_conv.is_owned = false;
49057 LDKCVec_PublicKeyZ intermediate_nodes_constr;
49058 intermediate_nodes_constr.datalen = intermediate_nodes->arr_len;
49059 if (intermediate_nodes_constr.datalen > 0)
49060 intermediate_nodes_constr.data = MALLOC(intermediate_nodes_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
49062 intermediate_nodes_constr.data = NULL;
49063 int8_tArray* intermediate_nodes_vals = (void*) intermediate_nodes->elems;
49064 for (size_t m = 0; m < intermediate_nodes_constr.datalen; m++) {
49065 int8_tArray intermediate_nodes_conv_12 = intermediate_nodes_vals[m];
49066 LDKPublicKey intermediate_nodes_conv_12_ref;
49067 CHECK(intermediate_nodes_conv_12->arr_len == 33);
49068 memcpy(intermediate_nodes_conv_12_ref.compressed_form, intermediate_nodes_conv_12->elems, 33); FREE(intermediate_nodes_conv_12);
49069 intermediate_nodes_constr.data[m] = intermediate_nodes_conv_12_ref;
49071 FREE(intermediate_nodes);
49072 void* destination_ptr = untag_ptr(destination);
49073 CHECK_ACCESS(destination_ptr);
49074 LDKDestination destination_conv = *(LDKDestination*)(destination_ptr);
49075 destination_conv = Destination_clone((LDKDestination*)untag_ptr(destination));
49076 void* message_ptr = untag_ptr(message);
49077 CHECK_ACCESS(message_ptr);
49078 LDKOnionMessageContents message_conv = *(LDKOnionMessageContents*)(message_ptr);
49079 message_conv = OnionMessageContents_clone((LDKOnionMessageContents*)untag_ptr(message));
49080 LDKBlindedPath reply_path_conv;
49081 reply_path_conv.inner = untag_ptr(reply_path);
49082 reply_path_conv.is_owned = ptr_is_owned(reply_path);
49083 CHECK_INNER_FIELD_ACCESS_OR_NULL(reply_path_conv);
49084 reply_path_conv = BlindedPath_clone(&reply_path_conv);
49085 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
49086 *ret_conv = OnionMessenger_send_onion_message(&this_arg_conv, intermediate_nodes_constr, destination_conv, message_conv, reply_path_conv);
49087 return tag_ptr(ret_conv, true);
49090 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageHandler"))) TS_OnionMessenger_as_OnionMessageHandler(uint64_t this_arg) {
49091 LDKOnionMessenger this_arg_conv;
49092 this_arg_conv.inner = untag_ptr(this_arg);
49093 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49095 this_arg_conv.is_owned = false;
49096 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
49097 *ret_ret = OnionMessenger_as_OnionMessageHandler(&this_arg_conv);
49098 return tag_ptr(ret_ret, true);
49101 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageProvider"))) TS_OnionMessenger_as_OnionMessageProvider(uint64_t this_arg) {
49102 LDKOnionMessenger this_arg_conv;
49103 this_arg_conv.inner = untag_ptr(this_arg);
49104 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49106 this_arg_conv.is_owned = false;
49107 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
49108 *ret_ret = OnionMessenger_as_OnionMessageProvider(&this_arg_conv);
49109 return tag_ptr(ret_ret, true);
49112 void __attribute__((export_name("TS_OnionMessageContents_free"))) TS_OnionMessageContents_free(uint64_t this_ptr) {
49113 if (!ptr_is_owned(this_ptr)) return;
49114 void* this_ptr_ptr = untag_ptr(this_ptr);
49115 CHECK_ACCESS(this_ptr_ptr);
49116 LDKOnionMessageContents this_ptr_conv = *(LDKOnionMessageContents*)(this_ptr_ptr);
49117 FREE(untag_ptr(this_ptr));
49118 OnionMessageContents_free(this_ptr_conv);
49121 static inline uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg) {
49122 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
49123 *ret_copy = OnionMessageContents_clone(arg);
49124 uint64_t ret_ref = tag_ptr(ret_copy, true);
49127 int64_t __attribute__((export_name("TS_OnionMessageContents_clone_ptr"))) TS_OnionMessageContents_clone_ptr(uint64_t arg) {
49128 LDKOnionMessageContents* arg_conv = (LDKOnionMessageContents*)untag_ptr(arg);
49129 int64_t ret_conv = OnionMessageContents_clone_ptr(arg_conv);
49133 uint64_t __attribute__((export_name("TS_OnionMessageContents_clone"))) TS_OnionMessageContents_clone(uint64_t orig) {
49134 LDKOnionMessageContents* orig_conv = (LDKOnionMessageContents*)untag_ptr(orig);
49135 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
49136 *ret_copy = OnionMessageContents_clone(orig_conv);
49137 uint64_t ret_ref = tag_ptr(ret_copy, true);
49141 uint64_t __attribute__((export_name("TS_OnionMessageContents_custom"))) TS_OnionMessageContents_custom(uint64_t a) {
49142 void* a_ptr = untag_ptr(a);
49143 CHECK_ACCESS(a_ptr);
49144 LDKCustomOnionMessageContents a_conv = *(LDKCustomOnionMessageContents*)(a_ptr);
49145 if (a_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
49146 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49147 LDKCustomOnionMessageContents_JCalls_cloned(&a_conv);
49149 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
49150 *ret_copy = OnionMessageContents_custom(a_conv);
49151 uint64_t ret_ref = tag_ptr(ret_copy, true);
49155 static inline uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg) {
49156 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
49157 *ret_ret = CustomOnionMessageContents_clone(arg);
49158 return tag_ptr(ret_ret, true);
49160 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone_ptr"))) TS_CustomOnionMessageContents_clone_ptr(uint64_t arg) {
49161 void* arg_ptr = untag_ptr(arg);
49162 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
49163 LDKCustomOnionMessageContents* arg_conv = (LDKCustomOnionMessageContents*)arg_ptr;
49164 int64_t ret_conv = CustomOnionMessageContents_clone_ptr(arg_conv);
49168 uint64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone"))) TS_CustomOnionMessageContents_clone(uint64_t orig) {
49169 void* orig_ptr = untag_ptr(orig);
49170 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
49171 LDKCustomOnionMessageContents* orig_conv = (LDKCustomOnionMessageContents*)orig_ptr;
49172 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
49173 *ret_ret = CustomOnionMessageContents_clone(orig_conv);
49174 return tag_ptr(ret_ret, true);
49177 void __attribute__((export_name("TS_CustomOnionMessageContents_free"))) TS_CustomOnionMessageContents_free(uint64_t this_ptr) {
49178 if (!ptr_is_owned(this_ptr)) return;
49179 void* this_ptr_ptr = untag_ptr(this_ptr);
49180 CHECK_ACCESS(this_ptr_ptr);
49181 LDKCustomOnionMessageContents this_ptr_conv = *(LDKCustomOnionMessageContents*)(this_ptr_ptr);
49182 FREE(untag_ptr(this_ptr));
49183 CustomOnionMessageContents_free(this_ptr_conv);
49186 void __attribute__((export_name("TS_BlindedPath_free"))) TS_BlindedPath_free(uint64_t this_obj) {
49187 LDKBlindedPath this_obj_conv;
49188 this_obj_conv.inner = untag_ptr(this_obj);
49189 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49191 BlindedPath_free(this_obj_conv);
49194 static inline uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg) {
49195 LDKBlindedPath ret_var = BlindedPath_clone(arg);
49196 uint64_t ret_ref = 0;
49197 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49198 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49201 int64_t __attribute__((export_name("TS_BlindedPath_clone_ptr"))) TS_BlindedPath_clone_ptr(uint64_t arg) {
49202 LDKBlindedPath arg_conv;
49203 arg_conv.inner = untag_ptr(arg);
49204 arg_conv.is_owned = ptr_is_owned(arg);
49205 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49206 arg_conv.is_owned = false;
49207 int64_t ret_conv = BlindedPath_clone_ptr(&arg_conv);
49211 uint64_t __attribute__((export_name("TS_BlindedPath_clone"))) TS_BlindedPath_clone(uint64_t orig) {
49212 LDKBlindedPath orig_conv;
49213 orig_conv.inner = untag_ptr(orig);
49214 orig_conv.is_owned = ptr_is_owned(orig);
49215 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49216 orig_conv.is_owned = false;
49217 LDKBlindedPath ret_var = BlindedPath_clone(&orig_conv);
49218 uint64_t ret_ref = 0;
49219 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49220 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49224 int64_t __attribute__((export_name("TS_BlindedPath_hash"))) TS_BlindedPath_hash(uint64_t o) {
49225 LDKBlindedPath o_conv;
49226 o_conv.inner = untag_ptr(o);
49227 o_conv.is_owned = ptr_is_owned(o);
49228 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
49229 o_conv.is_owned = false;
49230 int64_t ret_conv = BlindedPath_hash(&o_conv);
49234 jboolean __attribute__((export_name("TS_BlindedPath_eq"))) TS_BlindedPath_eq(uint64_t a, uint64_t b) {
49235 LDKBlindedPath a_conv;
49236 a_conv.inner = untag_ptr(a);
49237 a_conv.is_owned = ptr_is_owned(a);
49238 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49239 a_conv.is_owned = false;
49240 LDKBlindedPath b_conv;
49241 b_conv.inner = untag_ptr(b);
49242 b_conv.is_owned = ptr_is_owned(b);
49243 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49244 b_conv.is_owned = false;
49245 jboolean ret_conv = BlindedPath_eq(&a_conv, &b_conv);
49249 void __attribute__((export_name("TS_BlindedHop_free"))) TS_BlindedHop_free(uint64_t this_obj) {
49250 LDKBlindedHop this_obj_conv;
49251 this_obj_conv.inner = untag_ptr(this_obj);
49252 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49254 BlindedHop_free(this_obj_conv);
49257 static inline uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg) {
49258 LDKBlindedHop ret_var = BlindedHop_clone(arg);
49259 uint64_t ret_ref = 0;
49260 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49261 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49264 int64_t __attribute__((export_name("TS_BlindedHop_clone_ptr"))) TS_BlindedHop_clone_ptr(uint64_t arg) {
49265 LDKBlindedHop arg_conv;
49266 arg_conv.inner = untag_ptr(arg);
49267 arg_conv.is_owned = ptr_is_owned(arg);
49268 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49269 arg_conv.is_owned = false;
49270 int64_t ret_conv = BlindedHop_clone_ptr(&arg_conv);
49274 uint64_t __attribute__((export_name("TS_BlindedHop_clone"))) TS_BlindedHop_clone(uint64_t orig) {
49275 LDKBlindedHop orig_conv;
49276 orig_conv.inner = untag_ptr(orig);
49277 orig_conv.is_owned = ptr_is_owned(orig);
49278 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49279 orig_conv.is_owned = false;
49280 LDKBlindedHop ret_var = BlindedHop_clone(&orig_conv);
49281 uint64_t ret_ref = 0;
49282 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49283 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49287 int64_t __attribute__((export_name("TS_BlindedHop_hash"))) TS_BlindedHop_hash(uint64_t o) {
49288 LDKBlindedHop o_conv;
49289 o_conv.inner = untag_ptr(o);
49290 o_conv.is_owned = ptr_is_owned(o);
49291 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
49292 o_conv.is_owned = false;
49293 int64_t ret_conv = BlindedHop_hash(&o_conv);
49297 jboolean __attribute__((export_name("TS_BlindedHop_eq"))) TS_BlindedHop_eq(uint64_t a, uint64_t b) {
49298 LDKBlindedHop a_conv;
49299 a_conv.inner = untag_ptr(a);
49300 a_conv.is_owned = ptr_is_owned(a);
49301 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49302 a_conv.is_owned = false;
49303 LDKBlindedHop b_conv;
49304 b_conv.inner = untag_ptr(b);
49305 b_conv.is_owned = ptr_is_owned(b);
49306 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49307 b_conv.is_owned = false;
49308 jboolean ret_conv = BlindedHop_eq(&a_conv, &b_conv);
49312 uint64_t __attribute__((export_name("TS_BlindedPath_new_for_message"))) TS_BlindedPath_new_for_message(ptrArray node_pks, uint64_t entropy_source) {
49313 LDKCVec_PublicKeyZ node_pks_constr;
49314 node_pks_constr.datalen = node_pks->arr_len;
49315 if (node_pks_constr.datalen > 0)
49316 node_pks_constr.data = MALLOC(node_pks_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
49318 node_pks_constr.data = NULL;
49319 int8_tArray* node_pks_vals = (void*) node_pks->elems;
49320 for (size_t m = 0; m < node_pks_constr.datalen; m++) {
49321 int8_tArray node_pks_conv_12 = node_pks_vals[m];
49322 LDKPublicKey node_pks_conv_12_ref;
49323 CHECK(node_pks_conv_12->arr_len == 33);
49324 memcpy(node_pks_conv_12_ref.compressed_form, node_pks_conv_12->elems, 33); FREE(node_pks_conv_12);
49325 node_pks_constr.data[m] = node_pks_conv_12_ref;
49328 void* entropy_source_ptr = untag_ptr(entropy_source);
49329 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
49330 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
49331 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
49332 *ret_conv = BlindedPath_new_for_message(node_pks_constr, entropy_source_conv);
49333 return tag_ptr(ret_conv, true);
49336 int8_tArray __attribute__((export_name("TS_BlindedPath_write"))) TS_BlindedPath_write(uint64_t obj) {
49337 LDKBlindedPath obj_conv;
49338 obj_conv.inner = untag_ptr(obj);
49339 obj_conv.is_owned = ptr_is_owned(obj);
49340 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
49341 obj_conv.is_owned = false;
49342 LDKCVec_u8Z ret_var = BlindedPath_write(&obj_conv);
49343 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49344 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49345 CVec_u8Z_free(ret_var);
49349 uint64_t __attribute__((export_name("TS_BlindedPath_read"))) TS_BlindedPath_read(int8_tArray ser) {
49350 LDKu8slice ser_ref;
49351 ser_ref.datalen = ser->arr_len;
49352 ser_ref.data = ser->elems;
49353 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
49354 *ret_conv = BlindedPath_read(ser_ref);
49356 return tag_ptr(ret_conv, true);
49359 int8_tArray __attribute__((export_name("TS_BlindedHop_write"))) TS_BlindedHop_write(uint64_t obj) {
49360 LDKBlindedHop obj_conv;
49361 obj_conv.inner = untag_ptr(obj);
49362 obj_conv.is_owned = ptr_is_owned(obj);
49363 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
49364 obj_conv.is_owned = false;
49365 LDKCVec_u8Z ret_var = BlindedHop_write(&obj_conv);
49366 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49367 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49368 CVec_u8Z_free(ret_var);
49372 uint64_t __attribute__((export_name("TS_BlindedHop_read"))) TS_BlindedHop_read(int8_tArray ser) {
49373 LDKu8slice ser_ref;
49374 ser_ref.datalen = ser->arr_len;
49375 ser_ref.data = ser->elems;
49376 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
49377 *ret_conv = BlindedHop_read(ser_ref);
49379 return tag_ptr(ret_conv, true);
49382 void __attribute__((export_name("TS_PaymentPurpose_free"))) TS_PaymentPurpose_free(uint64_t this_ptr) {
49383 if (!ptr_is_owned(this_ptr)) return;
49384 void* this_ptr_ptr = untag_ptr(this_ptr);
49385 CHECK_ACCESS(this_ptr_ptr);
49386 LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(this_ptr_ptr);
49387 FREE(untag_ptr(this_ptr));
49388 PaymentPurpose_free(this_ptr_conv);
49391 static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
49392 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49393 *ret_copy = PaymentPurpose_clone(arg);
49394 uint64_t ret_ref = tag_ptr(ret_copy, true);
49397 int64_t __attribute__((export_name("TS_PaymentPurpose_clone_ptr"))) TS_PaymentPurpose_clone_ptr(uint64_t arg) {
49398 LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)untag_ptr(arg);
49399 int64_t ret_conv = PaymentPurpose_clone_ptr(arg_conv);
49403 uint64_t __attribute__((export_name("TS_PaymentPurpose_clone"))) TS_PaymentPurpose_clone(uint64_t orig) {
49404 LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)untag_ptr(orig);
49405 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49406 *ret_copy = PaymentPurpose_clone(orig_conv);
49407 uint64_t ret_ref = tag_ptr(ret_copy, true);
49411 uint64_t __attribute__((export_name("TS_PaymentPurpose_invoice_payment"))) TS_PaymentPurpose_invoice_payment(int8_tArray payment_preimage, int8_tArray payment_secret) {
49412 LDKThirtyTwoBytes payment_preimage_ref;
49413 CHECK(payment_preimage->arr_len == 32);
49414 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
49415 LDKThirtyTwoBytes payment_secret_ref;
49416 CHECK(payment_secret->arr_len == 32);
49417 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
49418 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49419 *ret_copy = PaymentPurpose_invoice_payment(payment_preimage_ref, payment_secret_ref);
49420 uint64_t ret_ref = tag_ptr(ret_copy, true);
49424 uint64_t __attribute__((export_name("TS_PaymentPurpose_spontaneous_payment"))) TS_PaymentPurpose_spontaneous_payment(int8_tArray a) {
49425 LDKThirtyTwoBytes a_ref;
49426 CHECK(a->arr_len == 32);
49427 memcpy(a_ref.data, a->elems, 32); FREE(a);
49428 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49429 *ret_copy = PaymentPurpose_spontaneous_payment(a_ref);
49430 uint64_t ret_ref = tag_ptr(ret_copy, true);
49434 jboolean __attribute__((export_name("TS_PaymentPurpose_eq"))) TS_PaymentPurpose_eq(uint64_t a, uint64_t b) {
49435 LDKPaymentPurpose* a_conv = (LDKPaymentPurpose*)untag_ptr(a);
49436 LDKPaymentPurpose* b_conv = (LDKPaymentPurpose*)untag_ptr(b);
49437 jboolean ret_conv = PaymentPurpose_eq(a_conv, b_conv);
49441 int8_tArray __attribute__((export_name("TS_PaymentPurpose_write"))) TS_PaymentPurpose_write(uint64_t obj) {
49442 LDKPaymentPurpose* obj_conv = (LDKPaymentPurpose*)untag_ptr(obj);
49443 LDKCVec_u8Z ret_var = PaymentPurpose_write(obj_conv);
49444 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49445 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49446 CVec_u8Z_free(ret_var);
49450 uint64_t __attribute__((export_name("TS_PaymentPurpose_read"))) TS_PaymentPurpose_read(int8_tArray ser) {
49451 LDKu8slice ser_ref;
49452 ser_ref.datalen = ser->arr_len;
49453 ser_ref.data = ser->elems;
49454 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
49455 *ret_conv = PaymentPurpose_read(ser_ref);
49457 return tag_ptr(ret_conv, true);
49460 void __attribute__((export_name("TS_PathFailure_free"))) TS_PathFailure_free(uint64_t this_ptr) {
49461 if (!ptr_is_owned(this_ptr)) return;
49462 void* this_ptr_ptr = untag_ptr(this_ptr);
49463 CHECK_ACCESS(this_ptr_ptr);
49464 LDKPathFailure this_ptr_conv = *(LDKPathFailure*)(this_ptr_ptr);
49465 FREE(untag_ptr(this_ptr));
49466 PathFailure_free(this_ptr_conv);
49469 static inline uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg) {
49470 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49471 *ret_copy = PathFailure_clone(arg);
49472 uint64_t ret_ref = tag_ptr(ret_copy, true);
49475 int64_t __attribute__((export_name("TS_PathFailure_clone_ptr"))) TS_PathFailure_clone_ptr(uint64_t arg) {
49476 LDKPathFailure* arg_conv = (LDKPathFailure*)untag_ptr(arg);
49477 int64_t ret_conv = PathFailure_clone_ptr(arg_conv);
49481 uint64_t __attribute__((export_name("TS_PathFailure_clone"))) TS_PathFailure_clone(uint64_t orig) {
49482 LDKPathFailure* orig_conv = (LDKPathFailure*)untag_ptr(orig);
49483 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49484 *ret_copy = PathFailure_clone(orig_conv);
49485 uint64_t ret_ref = tag_ptr(ret_copy, true);
49489 uint64_t __attribute__((export_name("TS_PathFailure_initial_send"))) TS_PathFailure_initial_send(uint64_t err) {
49490 void* err_ptr = untag_ptr(err);
49491 CHECK_ACCESS(err_ptr);
49492 LDKAPIError err_conv = *(LDKAPIError*)(err_ptr);
49493 err_conv = APIError_clone((LDKAPIError*)untag_ptr(err));
49494 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49495 *ret_copy = PathFailure_initial_send(err_conv);
49496 uint64_t ret_ref = tag_ptr(ret_copy, true);
49500 uint64_t __attribute__((export_name("TS_PathFailure_on_path"))) TS_PathFailure_on_path(uint64_t network_update) {
49501 void* network_update_ptr = untag_ptr(network_update);
49502 CHECK_ACCESS(network_update_ptr);
49503 LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(network_update_ptr);
49504 network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(network_update));
49505 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49506 *ret_copy = PathFailure_on_path(network_update_conv);
49507 uint64_t ret_ref = tag_ptr(ret_copy, true);
49511 jboolean __attribute__((export_name("TS_PathFailure_eq"))) TS_PathFailure_eq(uint64_t a, uint64_t b) {
49512 LDKPathFailure* a_conv = (LDKPathFailure*)untag_ptr(a);
49513 LDKPathFailure* b_conv = (LDKPathFailure*)untag_ptr(b);
49514 jboolean ret_conv = PathFailure_eq(a_conv, b_conv);
49518 int8_tArray __attribute__((export_name("TS_PathFailure_write"))) TS_PathFailure_write(uint64_t obj) {
49519 LDKPathFailure* obj_conv = (LDKPathFailure*)untag_ptr(obj);
49520 LDKCVec_u8Z ret_var = PathFailure_write(obj_conv);
49521 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49522 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49523 CVec_u8Z_free(ret_var);
49527 uint64_t __attribute__((export_name("TS_PathFailure_read"))) TS_PathFailure_read(int8_tArray ser) {
49528 LDKu8slice ser_ref;
49529 ser_ref.datalen = ser->arr_len;
49530 ser_ref.data = ser->elems;
49531 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
49532 *ret_conv = PathFailure_read(ser_ref);
49534 return tag_ptr(ret_conv, true);
49537 void __attribute__((export_name("TS_ClosureReason_free"))) TS_ClosureReason_free(uint64_t this_ptr) {
49538 if (!ptr_is_owned(this_ptr)) return;
49539 void* this_ptr_ptr = untag_ptr(this_ptr);
49540 CHECK_ACCESS(this_ptr_ptr);
49541 LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(this_ptr_ptr);
49542 FREE(untag_ptr(this_ptr));
49543 ClosureReason_free(this_ptr_conv);
49546 static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
49547 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49548 *ret_copy = ClosureReason_clone(arg);
49549 uint64_t ret_ref = tag_ptr(ret_copy, true);
49552 int64_t __attribute__((export_name("TS_ClosureReason_clone_ptr"))) TS_ClosureReason_clone_ptr(uint64_t arg) {
49553 LDKClosureReason* arg_conv = (LDKClosureReason*)untag_ptr(arg);
49554 int64_t ret_conv = ClosureReason_clone_ptr(arg_conv);
49558 uint64_t __attribute__((export_name("TS_ClosureReason_clone"))) TS_ClosureReason_clone(uint64_t orig) {
49559 LDKClosureReason* orig_conv = (LDKClosureReason*)untag_ptr(orig);
49560 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49561 *ret_copy = ClosureReason_clone(orig_conv);
49562 uint64_t ret_ref = tag_ptr(ret_copy, true);
49566 uint64_t __attribute__((export_name("TS_ClosureReason_counterparty_force_closed"))) TS_ClosureReason_counterparty_force_closed(uint64_t peer_msg) {
49567 LDKUntrustedString peer_msg_conv;
49568 peer_msg_conv.inner = untag_ptr(peer_msg);
49569 peer_msg_conv.is_owned = ptr_is_owned(peer_msg);
49570 CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_msg_conv);
49571 peer_msg_conv = UntrustedString_clone(&peer_msg_conv);
49572 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49573 *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv);
49574 uint64_t ret_ref = tag_ptr(ret_copy, true);
49578 uint64_t __attribute__((export_name("TS_ClosureReason_holder_force_closed"))) TS_ClosureReason_holder_force_closed() {
49579 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49580 *ret_copy = ClosureReason_holder_force_closed();
49581 uint64_t ret_ref = tag_ptr(ret_copy, true);
49585 uint64_t __attribute__((export_name("TS_ClosureReason_cooperative_closure"))) TS_ClosureReason_cooperative_closure() {
49586 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49587 *ret_copy = ClosureReason_cooperative_closure();
49588 uint64_t ret_ref = tag_ptr(ret_copy, true);
49592 uint64_t __attribute__((export_name("TS_ClosureReason_commitment_tx_confirmed"))) TS_ClosureReason_commitment_tx_confirmed() {
49593 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49594 *ret_copy = ClosureReason_commitment_tx_confirmed();
49595 uint64_t ret_ref = tag_ptr(ret_copy, true);
49599 uint64_t __attribute__((export_name("TS_ClosureReason_funding_timed_out"))) TS_ClosureReason_funding_timed_out() {
49600 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49601 *ret_copy = ClosureReason_funding_timed_out();
49602 uint64_t ret_ref = tag_ptr(ret_copy, true);
49606 uint64_t __attribute__((export_name("TS_ClosureReason_processing_error"))) TS_ClosureReason_processing_error(jstring err) {
49607 LDKStr err_conv = str_ref_to_owned_c(err);
49608 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49609 *ret_copy = ClosureReason_processing_error(err_conv);
49610 uint64_t ret_ref = tag_ptr(ret_copy, true);
49614 uint64_t __attribute__((export_name("TS_ClosureReason_disconnected_peer"))) TS_ClosureReason_disconnected_peer() {
49615 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49616 *ret_copy = ClosureReason_disconnected_peer();
49617 uint64_t ret_ref = tag_ptr(ret_copy, true);
49621 uint64_t __attribute__((export_name("TS_ClosureReason_outdated_channel_manager"))) TS_ClosureReason_outdated_channel_manager() {
49622 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49623 *ret_copy = ClosureReason_outdated_channel_manager();
49624 uint64_t ret_ref = tag_ptr(ret_copy, true);
49628 jboolean __attribute__((export_name("TS_ClosureReason_eq"))) TS_ClosureReason_eq(uint64_t a, uint64_t b) {
49629 LDKClosureReason* a_conv = (LDKClosureReason*)untag_ptr(a);
49630 LDKClosureReason* b_conv = (LDKClosureReason*)untag_ptr(b);
49631 jboolean ret_conv = ClosureReason_eq(a_conv, b_conv);
49635 int8_tArray __attribute__((export_name("TS_ClosureReason_write"))) TS_ClosureReason_write(uint64_t obj) {
49636 LDKClosureReason* obj_conv = (LDKClosureReason*)untag_ptr(obj);
49637 LDKCVec_u8Z ret_var = ClosureReason_write(obj_conv);
49638 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49639 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49640 CVec_u8Z_free(ret_var);
49644 uint64_t __attribute__((export_name("TS_ClosureReason_read"))) TS_ClosureReason_read(int8_tArray ser) {
49645 LDKu8slice ser_ref;
49646 ser_ref.datalen = ser->arr_len;
49647 ser_ref.data = ser->elems;
49648 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
49649 *ret_conv = ClosureReason_read(ser_ref);
49651 return tag_ptr(ret_conv, true);
49654 void __attribute__((export_name("TS_HTLCDestination_free"))) TS_HTLCDestination_free(uint64_t this_ptr) {
49655 if (!ptr_is_owned(this_ptr)) return;
49656 void* this_ptr_ptr = untag_ptr(this_ptr);
49657 CHECK_ACCESS(this_ptr_ptr);
49658 LDKHTLCDestination this_ptr_conv = *(LDKHTLCDestination*)(this_ptr_ptr);
49659 FREE(untag_ptr(this_ptr));
49660 HTLCDestination_free(this_ptr_conv);
49663 static inline uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg) {
49664 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49665 *ret_copy = HTLCDestination_clone(arg);
49666 uint64_t ret_ref = tag_ptr(ret_copy, true);
49669 int64_t __attribute__((export_name("TS_HTLCDestination_clone_ptr"))) TS_HTLCDestination_clone_ptr(uint64_t arg) {
49670 LDKHTLCDestination* arg_conv = (LDKHTLCDestination*)untag_ptr(arg);
49671 int64_t ret_conv = HTLCDestination_clone_ptr(arg_conv);
49675 uint64_t __attribute__((export_name("TS_HTLCDestination_clone"))) TS_HTLCDestination_clone(uint64_t orig) {
49676 LDKHTLCDestination* orig_conv = (LDKHTLCDestination*)untag_ptr(orig);
49677 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49678 *ret_copy = HTLCDestination_clone(orig_conv);
49679 uint64_t ret_ref = tag_ptr(ret_copy, true);
49683 uint64_t __attribute__((export_name("TS_HTLCDestination_next_hop_channel"))) TS_HTLCDestination_next_hop_channel(int8_tArray node_id, int8_tArray channel_id) {
49684 LDKPublicKey node_id_ref;
49685 CHECK(node_id->arr_len == 33);
49686 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
49687 LDKThirtyTwoBytes channel_id_ref;
49688 CHECK(channel_id->arr_len == 32);
49689 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
49690 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49691 *ret_copy = HTLCDestination_next_hop_channel(node_id_ref, channel_id_ref);
49692 uint64_t ret_ref = tag_ptr(ret_copy, true);
49696 uint64_t __attribute__((export_name("TS_HTLCDestination_unknown_next_hop"))) TS_HTLCDestination_unknown_next_hop(int64_t requested_forward_scid) {
49697 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49698 *ret_copy = HTLCDestination_unknown_next_hop(requested_forward_scid);
49699 uint64_t ret_ref = tag_ptr(ret_copy, true);
49703 uint64_t __attribute__((export_name("TS_HTLCDestination_invalid_forward"))) TS_HTLCDestination_invalid_forward(int64_t requested_forward_scid) {
49704 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49705 *ret_copy = HTLCDestination_invalid_forward(requested_forward_scid);
49706 uint64_t ret_ref = tag_ptr(ret_copy, true);
49710 uint64_t __attribute__((export_name("TS_HTLCDestination_failed_payment"))) TS_HTLCDestination_failed_payment(int8_tArray payment_hash) {
49711 LDKThirtyTwoBytes payment_hash_ref;
49712 CHECK(payment_hash->arr_len == 32);
49713 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49714 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49715 *ret_copy = HTLCDestination_failed_payment(payment_hash_ref);
49716 uint64_t ret_ref = tag_ptr(ret_copy, true);
49720 jboolean __attribute__((export_name("TS_HTLCDestination_eq"))) TS_HTLCDestination_eq(uint64_t a, uint64_t b) {
49721 LDKHTLCDestination* a_conv = (LDKHTLCDestination*)untag_ptr(a);
49722 LDKHTLCDestination* b_conv = (LDKHTLCDestination*)untag_ptr(b);
49723 jboolean ret_conv = HTLCDestination_eq(a_conv, b_conv);
49727 int8_tArray __attribute__((export_name("TS_HTLCDestination_write"))) TS_HTLCDestination_write(uint64_t obj) {
49728 LDKHTLCDestination* obj_conv = (LDKHTLCDestination*)untag_ptr(obj);
49729 LDKCVec_u8Z ret_var = HTLCDestination_write(obj_conv);
49730 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49731 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49732 CVec_u8Z_free(ret_var);
49736 uint64_t __attribute__((export_name("TS_HTLCDestination_read"))) TS_HTLCDestination_read(int8_tArray ser) {
49737 LDKu8slice ser_ref;
49738 ser_ref.datalen = ser->arr_len;
49739 ser_ref.data = ser->elems;
49740 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
49741 *ret_conv = HTLCDestination_read(ser_ref);
49743 return tag_ptr(ret_conv, true);
49746 uint32_t __attribute__((export_name("TS_PaymentFailureReason_clone"))) TS_PaymentFailureReason_clone(uint64_t orig) {
49747 LDKPaymentFailureReason* orig_conv = (LDKPaymentFailureReason*)untag_ptr(orig);
49748 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_clone(orig_conv));
49752 uint32_t __attribute__((export_name("TS_PaymentFailureReason_recipient_rejected"))) TS_PaymentFailureReason_recipient_rejected() {
49753 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_recipient_rejected());
49757 uint32_t __attribute__((export_name("TS_PaymentFailureReason_user_abandoned"))) TS_PaymentFailureReason_user_abandoned() {
49758 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_user_abandoned());
49762 uint32_t __attribute__((export_name("TS_PaymentFailureReason_retries_exhausted"))) TS_PaymentFailureReason_retries_exhausted() {
49763 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_retries_exhausted());
49767 uint32_t __attribute__((export_name("TS_PaymentFailureReason_payment_expired"))) TS_PaymentFailureReason_payment_expired() {
49768 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_payment_expired());
49772 uint32_t __attribute__((export_name("TS_PaymentFailureReason_route_not_found"))) TS_PaymentFailureReason_route_not_found() {
49773 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_route_not_found());
49777 uint32_t __attribute__((export_name("TS_PaymentFailureReason_unexpected_error"))) TS_PaymentFailureReason_unexpected_error() {
49778 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_unexpected_error());
49782 jboolean __attribute__((export_name("TS_PaymentFailureReason_eq"))) TS_PaymentFailureReason_eq(uint64_t a, uint64_t b) {
49783 LDKPaymentFailureReason* a_conv = (LDKPaymentFailureReason*)untag_ptr(a);
49784 LDKPaymentFailureReason* b_conv = (LDKPaymentFailureReason*)untag_ptr(b);
49785 jboolean ret_conv = PaymentFailureReason_eq(a_conv, b_conv);
49789 int8_tArray __attribute__((export_name("TS_PaymentFailureReason_write"))) TS_PaymentFailureReason_write(uint64_t obj) {
49790 LDKPaymentFailureReason* obj_conv = (LDKPaymentFailureReason*)untag_ptr(obj);
49791 LDKCVec_u8Z ret_var = PaymentFailureReason_write(obj_conv);
49792 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49793 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49794 CVec_u8Z_free(ret_var);
49798 uint64_t __attribute__((export_name("TS_PaymentFailureReason_read"))) TS_PaymentFailureReason_read(int8_tArray ser) {
49799 LDKu8slice ser_ref;
49800 ser_ref.datalen = ser->arr_len;
49801 ser_ref.data = ser->elems;
49802 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
49803 *ret_conv = PaymentFailureReason_read(ser_ref);
49805 return tag_ptr(ret_conv, true);
49808 void __attribute__((export_name("TS_Event_free"))) TS_Event_free(uint64_t this_ptr) {
49809 if (!ptr_is_owned(this_ptr)) return;
49810 void* this_ptr_ptr = untag_ptr(this_ptr);
49811 CHECK_ACCESS(this_ptr_ptr);
49812 LDKEvent this_ptr_conv = *(LDKEvent*)(this_ptr_ptr);
49813 FREE(untag_ptr(this_ptr));
49814 Event_free(this_ptr_conv);
49817 static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
49818 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49819 *ret_copy = Event_clone(arg);
49820 uint64_t ret_ref = tag_ptr(ret_copy, true);
49823 int64_t __attribute__((export_name("TS_Event_clone_ptr"))) TS_Event_clone_ptr(uint64_t arg) {
49824 LDKEvent* arg_conv = (LDKEvent*)untag_ptr(arg);
49825 int64_t ret_conv = Event_clone_ptr(arg_conv);
49829 uint64_t __attribute__((export_name("TS_Event_clone"))) TS_Event_clone(uint64_t orig) {
49830 LDKEvent* orig_conv = (LDKEvent*)untag_ptr(orig);
49831 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49832 *ret_copy = Event_clone(orig_conv);
49833 uint64_t ret_ref = tag_ptr(ret_copy, true);
49837 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) {
49838 LDKThirtyTwoBytes temporary_channel_id_ref;
49839 CHECK(temporary_channel_id->arr_len == 32);
49840 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
49841 LDKPublicKey counterparty_node_id_ref;
49842 CHECK(counterparty_node_id->arr_len == 33);
49843 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
49844 LDKCVec_u8Z output_script_ref;
49845 output_script_ref.datalen = output_script->arr_len;
49846 output_script_ref.data = MALLOC(output_script_ref.datalen, "LDKCVec_u8Z Bytes");
49847 memcpy(output_script_ref.data, output_script->elems, output_script_ref.datalen); FREE(output_script);
49848 LDKU128 user_channel_id_ref;
49849 CHECK(user_channel_id->arr_len == 16);
49850 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
49851 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49852 *ret_copy = Event_funding_generation_ready(temporary_channel_id_ref, counterparty_node_id_ref, channel_value_satoshis, output_script_ref, user_channel_id_ref);
49853 uint64_t ret_ref = tag_ptr(ret_copy, true);
49857 uint64_t __attribute__((export_name("TS_Event_payment_claimable"))) TS_Event_payment_claimable(int8_tArray receiver_node_id, int8_tArray payment_hash, uint64_t onion_fields, int64_t amount_msat, uint64_t purpose, int8_tArray via_channel_id, uint64_t via_user_channel_id, uint64_t claim_deadline) {
49858 LDKPublicKey receiver_node_id_ref;
49859 CHECK(receiver_node_id->arr_len == 33);
49860 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
49861 LDKThirtyTwoBytes payment_hash_ref;
49862 CHECK(payment_hash->arr_len == 32);
49863 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49864 LDKRecipientOnionFields onion_fields_conv;
49865 onion_fields_conv.inner = untag_ptr(onion_fields);
49866 onion_fields_conv.is_owned = ptr_is_owned(onion_fields);
49867 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_fields_conv);
49868 onion_fields_conv = RecipientOnionFields_clone(&onion_fields_conv);
49869 void* purpose_ptr = untag_ptr(purpose);
49870 CHECK_ACCESS(purpose_ptr);
49871 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
49872 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
49873 LDKThirtyTwoBytes via_channel_id_ref;
49874 CHECK(via_channel_id->arr_len == 32);
49875 memcpy(via_channel_id_ref.data, via_channel_id->elems, 32); FREE(via_channel_id);
49876 void* via_user_channel_id_ptr = untag_ptr(via_user_channel_id);
49877 CHECK_ACCESS(via_user_channel_id_ptr);
49878 LDKCOption_u128Z via_user_channel_id_conv = *(LDKCOption_u128Z*)(via_user_channel_id_ptr);
49879 via_user_channel_id_conv = COption_u128Z_clone((LDKCOption_u128Z*)untag_ptr(via_user_channel_id));
49880 void* claim_deadline_ptr = untag_ptr(claim_deadline);
49881 CHECK_ACCESS(claim_deadline_ptr);
49882 LDKCOption_u32Z claim_deadline_conv = *(LDKCOption_u32Z*)(claim_deadline_ptr);
49883 claim_deadline_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(claim_deadline));
49884 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49885 *ret_copy = Event_payment_claimable(receiver_node_id_ref, payment_hash_ref, onion_fields_conv, amount_msat, purpose_conv, via_channel_id_ref, via_user_channel_id_conv, claim_deadline_conv);
49886 uint64_t ret_ref = tag_ptr(ret_copy, true);
49890 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) {
49891 LDKPublicKey receiver_node_id_ref;
49892 CHECK(receiver_node_id->arr_len == 33);
49893 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
49894 LDKThirtyTwoBytes payment_hash_ref;
49895 CHECK(payment_hash->arr_len == 32);
49896 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49897 void* purpose_ptr = untag_ptr(purpose);
49898 CHECK_ACCESS(purpose_ptr);
49899 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
49900 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
49901 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49902 *ret_copy = Event_payment_claimed(receiver_node_id_ref, payment_hash_ref, amount_msat, purpose_conv);
49903 uint64_t ret_ref = tag_ptr(ret_copy, true);
49907 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) {
49908 LDKThirtyTwoBytes payment_id_ref;
49909 CHECK(payment_id->arr_len == 32);
49910 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49911 LDKThirtyTwoBytes payment_preimage_ref;
49912 CHECK(payment_preimage->arr_len == 32);
49913 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
49914 LDKThirtyTwoBytes payment_hash_ref;
49915 CHECK(payment_hash->arr_len == 32);
49916 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49917 void* fee_paid_msat_ptr = untag_ptr(fee_paid_msat);
49918 CHECK_ACCESS(fee_paid_msat_ptr);
49919 LDKCOption_u64Z fee_paid_msat_conv = *(LDKCOption_u64Z*)(fee_paid_msat_ptr);
49920 fee_paid_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_paid_msat));
49921 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49922 *ret_copy = Event_payment_sent(payment_id_ref, payment_preimage_ref, payment_hash_ref, fee_paid_msat_conv);
49923 uint64_t ret_ref = tag_ptr(ret_copy, true);
49927 uint64_t __attribute__((export_name("TS_Event_payment_failed"))) TS_Event_payment_failed(int8_tArray payment_id, int8_tArray payment_hash, uint64_t reason) {
49928 LDKThirtyTwoBytes payment_id_ref;
49929 CHECK(payment_id->arr_len == 32);
49930 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49931 LDKThirtyTwoBytes payment_hash_ref;
49932 CHECK(payment_hash->arr_len == 32);
49933 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49934 void* reason_ptr = untag_ptr(reason);
49935 CHECK_ACCESS(reason_ptr);
49936 LDKCOption_PaymentFailureReasonZ reason_conv = *(LDKCOption_PaymentFailureReasonZ*)(reason_ptr);
49937 reason_conv = COption_PaymentFailureReasonZ_clone((LDKCOption_PaymentFailureReasonZ*)untag_ptr(reason));
49938 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49939 *ret_copy = Event_payment_failed(payment_id_ref, payment_hash_ref, reason_conv);
49940 uint64_t ret_ref = tag_ptr(ret_copy, true);
49944 uint64_t __attribute__((export_name("TS_Event_payment_path_successful"))) TS_Event_payment_path_successful(int8_tArray payment_id, int8_tArray payment_hash, uint64_t path) {
49945 LDKThirtyTwoBytes payment_id_ref;
49946 CHECK(payment_id->arr_len == 32);
49947 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49948 LDKThirtyTwoBytes payment_hash_ref;
49949 CHECK(payment_hash->arr_len == 32);
49950 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49952 path_conv.inner = untag_ptr(path);
49953 path_conv.is_owned = ptr_is_owned(path);
49954 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
49955 path_conv = Path_clone(&path_conv);
49956 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49957 *ret_copy = Event_payment_path_successful(payment_id_ref, payment_hash_ref, path_conv);
49958 uint64_t ret_ref = tag_ptr(ret_copy, true);
49962 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 failure, uint64_t path, uint64_t short_channel_id) {
49963 LDKThirtyTwoBytes payment_id_ref;
49964 CHECK(payment_id->arr_len == 32);
49965 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49966 LDKThirtyTwoBytes payment_hash_ref;
49967 CHECK(payment_hash->arr_len == 32);
49968 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49969 void* failure_ptr = untag_ptr(failure);
49970 CHECK_ACCESS(failure_ptr);
49971 LDKPathFailure failure_conv = *(LDKPathFailure*)(failure_ptr);
49972 failure_conv = PathFailure_clone((LDKPathFailure*)untag_ptr(failure));
49974 path_conv.inner = untag_ptr(path);
49975 path_conv.is_owned = ptr_is_owned(path);
49976 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
49977 path_conv = Path_clone(&path_conv);
49978 void* short_channel_id_ptr = untag_ptr(short_channel_id);
49979 CHECK_ACCESS(short_channel_id_ptr);
49980 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
49981 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
49982 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49983 *ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, payment_failed_permanently, failure_conv, path_conv, short_channel_id_conv);
49984 uint64_t ret_ref = tag_ptr(ret_copy, true);
49988 uint64_t __attribute__((export_name("TS_Event_probe_successful"))) TS_Event_probe_successful(int8_tArray payment_id, int8_tArray payment_hash, uint64_t path) {
49989 LDKThirtyTwoBytes payment_id_ref;
49990 CHECK(payment_id->arr_len == 32);
49991 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49992 LDKThirtyTwoBytes payment_hash_ref;
49993 CHECK(payment_hash->arr_len == 32);
49994 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49996 path_conv.inner = untag_ptr(path);
49997 path_conv.is_owned = ptr_is_owned(path);
49998 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
49999 path_conv = Path_clone(&path_conv);
50000 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50001 *ret_copy = Event_probe_successful(payment_id_ref, payment_hash_ref, path_conv);
50002 uint64_t ret_ref = tag_ptr(ret_copy, true);
50006 uint64_t __attribute__((export_name("TS_Event_probe_failed"))) TS_Event_probe_failed(int8_tArray payment_id, int8_tArray payment_hash, uint64_t path, uint64_t short_channel_id) {
50007 LDKThirtyTwoBytes payment_id_ref;
50008 CHECK(payment_id->arr_len == 32);
50009 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
50010 LDKThirtyTwoBytes payment_hash_ref;
50011 CHECK(payment_hash->arr_len == 32);
50012 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
50014 path_conv.inner = untag_ptr(path);
50015 path_conv.is_owned = ptr_is_owned(path);
50016 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
50017 path_conv = Path_clone(&path_conv);
50018 void* short_channel_id_ptr = untag_ptr(short_channel_id);
50019 CHECK_ACCESS(short_channel_id_ptr);
50020 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
50021 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
50022 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50023 *ret_copy = Event_probe_failed(payment_id_ref, payment_hash_ref, path_conv, short_channel_id_conv);
50024 uint64_t ret_ref = tag_ptr(ret_copy, true);
50028 uint64_t __attribute__((export_name("TS_Event_pending_htlcs_forwardable"))) TS_Event_pending_htlcs_forwardable(int64_t time_forwardable) {
50029 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50030 *ret_copy = Event_pending_htlcs_forwardable(time_forwardable);
50031 uint64_t ret_ref = tag_ptr(ret_copy, true);
50035 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) {
50036 LDKThirtyTwoBytes intercept_id_ref;
50037 CHECK(intercept_id->arr_len == 32);
50038 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
50039 LDKThirtyTwoBytes payment_hash_ref;
50040 CHECK(payment_hash->arr_len == 32);
50041 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
50042 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50043 *ret_copy = Event_htlcintercepted(intercept_id_ref, requested_next_hop_scid, payment_hash_ref, inbound_amount_msat, expected_outbound_amount_msat);
50044 uint64_t ret_ref = tag_ptr(ret_copy, true);
50048 uint64_t __attribute__((export_name("TS_Event_spendable_outputs"))) TS_Event_spendable_outputs(uint64_tArray outputs) {
50049 LDKCVec_SpendableOutputDescriptorZ outputs_constr;
50050 outputs_constr.datalen = outputs->arr_len;
50051 if (outputs_constr.datalen > 0)
50052 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
50054 outputs_constr.data = NULL;
50055 uint64_t* outputs_vals = outputs->elems;
50056 for (size_t b = 0; b < outputs_constr.datalen; b++) {
50057 uint64_t outputs_conv_27 = outputs_vals[b];
50058 void* outputs_conv_27_ptr = untag_ptr(outputs_conv_27);
50059 CHECK_ACCESS(outputs_conv_27_ptr);
50060 LDKSpendableOutputDescriptor outputs_conv_27_conv = *(LDKSpendableOutputDescriptor*)(outputs_conv_27_ptr);
50061 outputs_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(outputs_conv_27));
50062 outputs_constr.data[b] = outputs_conv_27_conv;
50065 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50066 *ret_copy = Event_spendable_outputs(outputs_constr);
50067 uint64_t ret_ref = tag_ptr(ret_copy, true);
50071 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, uint64_t outbound_amount_forwarded_msat) {
50072 LDKThirtyTwoBytes prev_channel_id_ref;
50073 CHECK(prev_channel_id->arr_len == 32);
50074 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
50075 LDKThirtyTwoBytes next_channel_id_ref;
50076 CHECK(next_channel_id->arr_len == 32);
50077 memcpy(next_channel_id_ref.data, next_channel_id->elems, 32); FREE(next_channel_id);
50078 void* fee_earned_msat_ptr = untag_ptr(fee_earned_msat);
50079 CHECK_ACCESS(fee_earned_msat_ptr);
50080 LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(fee_earned_msat_ptr);
50081 fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_earned_msat));
50082 void* outbound_amount_forwarded_msat_ptr = untag_ptr(outbound_amount_forwarded_msat);
50083 CHECK_ACCESS(outbound_amount_forwarded_msat_ptr);
50084 LDKCOption_u64Z outbound_amount_forwarded_msat_conv = *(LDKCOption_u64Z*)(outbound_amount_forwarded_msat_ptr);
50085 outbound_amount_forwarded_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_amount_forwarded_msat));
50086 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50087 *ret_copy = Event_payment_forwarded(prev_channel_id_ref, next_channel_id_ref, fee_earned_msat_conv, claim_from_onchain_tx, outbound_amount_forwarded_msat_conv);
50088 uint64_t ret_ref = tag_ptr(ret_copy, true);
50092 uint64_t __attribute__((export_name("TS_Event_channel_pending"))) TS_Event_channel_pending(int8_tArray channel_id, int8_tArray user_channel_id, int8_tArray former_temporary_channel_id, int8_tArray counterparty_node_id, uint64_t funding_txo) {
50093 LDKThirtyTwoBytes channel_id_ref;
50094 CHECK(channel_id->arr_len == 32);
50095 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50096 LDKU128 user_channel_id_ref;
50097 CHECK(user_channel_id->arr_len == 16);
50098 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
50099 LDKThirtyTwoBytes former_temporary_channel_id_ref;
50100 CHECK(former_temporary_channel_id->arr_len == 32);
50101 memcpy(former_temporary_channel_id_ref.data, former_temporary_channel_id->elems, 32); FREE(former_temporary_channel_id);
50102 LDKPublicKey counterparty_node_id_ref;
50103 CHECK(counterparty_node_id->arr_len == 33);
50104 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
50105 LDKOutPoint funding_txo_conv;
50106 funding_txo_conv.inner = untag_ptr(funding_txo);
50107 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
50108 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
50109 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
50110 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50111 *ret_copy = Event_channel_pending(channel_id_ref, user_channel_id_ref, former_temporary_channel_id_ref, counterparty_node_id_ref, funding_txo_conv);
50112 uint64_t ret_ref = tag_ptr(ret_copy, true);
50116 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) {
50117 LDKThirtyTwoBytes channel_id_ref;
50118 CHECK(channel_id->arr_len == 32);
50119 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50120 LDKU128 user_channel_id_ref;
50121 CHECK(user_channel_id->arr_len == 16);
50122 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
50123 LDKPublicKey counterparty_node_id_ref;
50124 CHECK(counterparty_node_id->arr_len == 33);
50125 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
50126 LDKChannelTypeFeatures channel_type_conv;
50127 channel_type_conv.inner = untag_ptr(channel_type);
50128 channel_type_conv.is_owned = ptr_is_owned(channel_type);
50129 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
50130 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
50131 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50132 *ret_copy = Event_channel_ready(channel_id_ref, user_channel_id_ref, counterparty_node_id_ref, channel_type_conv);
50133 uint64_t ret_ref = tag_ptr(ret_copy, true);
50137 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) {
50138 LDKThirtyTwoBytes channel_id_ref;
50139 CHECK(channel_id->arr_len == 32);
50140 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50141 LDKU128 user_channel_id_ref;
50142 CHECK(user_channel_id->arr_len == 16);
50143 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
50144 void* reason_ptr = untag_ptr(reason);
50145 CHECK_ACCESS(reason_ptr);
50146 LDKClosureReason reason_conv = *(LDKClosureReason*)(reason_ptr);
50147 reason_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(reason));
50148 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50149 *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id_ref, reason_conv);
50150 uint64_t ret_ref = tag_ptr(ret_copy, true);
50154 uint64_t __attribute__((export_name("TS_Event_discard_funding"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) {
50155 LDKThirtyTwoBytes channel_id_ref;
50156 CHECK(channel_id->arr_len == 32);
50157 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50158 LDKTransaction transaction_ref;
50159 transaction_ref.datalen = transaction->arr_len;
50160 transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
50161 memcpy(transaction_ref.data, transaction->elems, transaction_ref.datalen); FREE(transaction);
50162 transaction_ref.data_is_owned = true;
50163 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50164 *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref);
50165 uint64_t ret_ref = tag_ptr(ret_copy, true);
50169 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) {
50170 LDKThirtyTwoBytes temporary_channel_id_ref;
50171 CHECK(temporary_channel_id->arr_len == 32);
50172 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
50173 LDKPublicKey counterparty_node_id_ref;
50174 CHECK(counterparty_node_id->arr_len == 33);
50175 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
50176 LDKChannelTypeFeatures channel_type_conv;
50177 channel_type_conv.inner = untag_ptr(channel_type);
50178 channel_type_conv.is_owned = ptr_is_owned(channel_type);
50179 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
50180 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
50181 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50182 *ret_copy = Event_open_channel_request(temporary_channel_id_ref, counterparty_node_id_ref, funding_satoshis, push_msat, channel_type_conv);
50183 uint64_t ret_ref = tag_ptr(ret_copy, true);
50187 uint64_t __attribute__((export_name("TS_Event_htlchandling_failed"))) TS_Event_htlchandling_failed(int8_tArray prev_channel_id, uint64_t failed_next_destination) {
50188 LDKThirtyTwoBytes prev_channel_id_ref;
50189 CHECK(prev_channel_id->arr_len == 32);
50190 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
50191 void* failed_next_destination_ptr = untag_ptr(failed_next_destination);
50192 CHECK_ACCESS(failed_next_destination_ptr);
50193 LDKHTLCDestination failed_next_destination_conv = *(LDKHTLCDestination*)(failed_next_destination_ptr);
50194 failed_next_destination_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(failed_next_destination));
50195 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50196 *ret_copy = Event_htlchandling_failed(prev_channel_id_ref, failed_next_destination_conv);
50197 uint64_t ret_ref = tag_ptr(ret_copy, true);
50201 jboolean __attribute__((export_name("TS_Event_eq"))) TS_Event_eq(uint64_t a, uint64_t b) {
50202 LDKEvent* a_conv = (LDKEvent*)untag_ptr(a);
50203 LDKEvent* b_conv = (LDKEvent*)untag_ptr(b);
50204 jboolean ret_conv = Event_eq(a_conv, b_conv);
50208 int8_tArray __attribute__((export_name("TS_Event_write"))) TS_Event_write(uint64_t obj) {
50209 LDKEvent* obj_conv = (LDKEvent*)untag_ptr(obj);
50210 LDKCVec_u8Z ret_var = Event_write(obj_conv);
50211 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50212 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50213 CVec_u8Z_free(ret_var);
50217 uint64_t __attribute__((export_name("TS_Event_read"))) TS_Event_read(int8_tArray ser) {
50218 LDKu8slice ser_ref;
50219 ser_ref.datalen = ser->arr_len;
50220 ser_ref.data = ser->elems;
50221 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
50222 *ret_conv = Event_read(ser_ref);
50224 return tag_ptr(ret_conv, true);
50227 void __attribute__((export_name("TS_MessageSendEvent_free"))) TS_MessageSendEvent_free(uint64_t this_ptr) {
50228 if (!ptr_is_owned(this_ptr)) return;
50229 void* this_ptr_ptr = untag_ptr(this_ptr);
50230 CHECK_ACCESS(this_ptr_ptr);
50231 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(this_ptr_ptr);
50232 FREE(untag_ptr(this_ptr));
50233 MessageSendEvent_free(this_ptr_conv);
50236 static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
50237 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50238 *ret_copy = MessageSendEvent_clone(arg);
50239 uint64_t ret_ref = tag_ptr(ret_copy, true);
50242 int64_t __attribute__((export_name("TS_MessageSendEvent_clone_ptr"))) TS_MessageSendEvent_clone_ptr(uint64_t arg) {
50243 LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)untag_ptr(arg);
50244 int64_t ret_conv = MessageSendEvent_clone_ptr(arg_conv);
50248 uint64_t __attribute__((export_name("TS_MessageSendEvent_clone"))) TS_MessageSendEvent_clone(uint64_t orig) {
50249 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)untag_ptr(orig);
50250 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50251 *ret_copy = MessageSendEvent_clone(orig_conv);
50252 uint64_t ret_ref = tag_ptr(ret_copy, true);
50256 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_accept_channel"))) TS_MessageSendEvent_send_accept_channel(int8_tArray node_id, uint64_t msg) {
50257 LDKPublicKey node_id_ref;
50258 CHECK(node_id->arr_len == 33);
50259 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50260 LDKAcceptChannel msg_conv;
50261 msg_conv.inner = untag_ptr(msg);
50262 msg_conv.is_owned = ptr_is_owned(msg);
50263 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50264 msg_conv = AcceptChannel_clone(&msg_conv);
50265 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50266 *ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
50267 uint64_t ret_ref = tag_ptr(ret_copy, true);
50271 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_open_channel"))) TS_MessageSendEvent_send_open_channel(int8_tArray node_id, uint64_t msg) {
50272 LDKPublicKey node_id_ref;
50273 CHECK(node_id->arr_len == 33);
50274 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50275 LDKOpenChannel msg_conv;
50276 msg_conv.inner = untag_ptr(msg);
50277 msg_conv.is_owned = ptr_is_owned(msg);
50278 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50279 msg_conv = OpenChannel_clone(&msg_conv);
50280 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50281 *ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
50282 uint64_t ret_ref = tag_ptr(ret_copy, true);
50286 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_created"))) TS_MessageSendEvent_send_funding_created(int8_tArray node_id, uint64_t msg) {
50287 LDKPublicKey node_id_ref;
50288 CHECK(node_id->arr_len == 33);
50289 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50290 LDKFundingCreated msg_conv;
50291 msg_conv.inner = untag_ptr(msg);
50292 msg_conv.is_owned = ptr_is_owned(msg);
50293 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50294 msg_conv = FundingCreated_clone(&msg_conv);
50295 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50296 *ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
50297 uint64_t ret_ref = tag_ptr(ret_copy, true);
50301 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_signed"))) TS_MessageSendEvent_send_funding_signed(int8_tArray node_id, uint64_t msg) {
50302 LDKPublicKey node_id_ref;
50303 CHECK(node_id->arr_len == 33);
50304 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50305 LDKFundingSigned msg_conv;
50306 msg_conv.inner = untag_ptr(msg);
50307 msg_conv.is_owned = ptr_is_owned(msg);
50308 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50309 msg_conv = FundingSigned_clone(&msg_conv);
50310 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50311 *ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
50312 uint64_t ret_ref = tag_ptr(ret_copy, true);
50316 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_ready"))) TS_MessageSendEvent_send_channel_ready(int8_tArray node_id, uint64_t msg) {
50317 LDKPublicKey node_id_ref;
50318 CHECK(node_id->arr_len == 33);
50319 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50320 LDKChannelReady msg_conv;
50321 msg_conv.inner = untag_ptr(msg);
50322 msg_conv.is_owned = ptr_is_owned(msg);
50323 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50324 msg_conv = ChannelReady_clone(&msg_conv);
50325 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50326 *ret_copy = MessageSendEvent_send_channel_ready(node_id_ref, msg_conv);
50327 uint64_t ret_ref = tag_ptr(ret_copy, true);
50331 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_announcement_signatures"))) TS_MessageSendEvent_send_announcement_signatures(int8_tArray node_id, uint64_t msg) {
50332 LDKPublicKey node_id_ref;
50333 CHECK(node_id->arr_len == 33);
50334 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50335 LDKAnnouncementSignatures msg_conv;
50336 msg_conv.inner = untag_ptr(msg);
50337 msg_conv.is_owned = ptr_is_owned(msg);
50338 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50339 msg_conv = AnnouncementSignatures_clone(&msg_conv);
50340 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50341 *ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
50342 uint64_t ret_ref = tag_ptr(ret_copy, true);
50346 uint64_t __attribute__((export_name("TS_MessageSendEvent_update_htlcs"))) TS_MessageSendEvent_update_htlcs(int8_tArray node_id, uint64_t updates) {
50347 LDKPublicKey node_id_ref;
50348 CHECK(node_id->arr_len == 33);
50349 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50350 LDKCommitmentUpdate updates_conv;
50351 updates_conv.inner = untag_ptr(updates);
50352 updates_conv.is_owned = ptr_is_owned(updates);
50353 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
50354 updates_conv = CommitmentUpdate_clone(&updates_conv);
50355 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50356 *ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
50357 uint64_t ret_ref = tag_ptr(ret_copy, true);
50361 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_revoke_and_ack"))) TS_MessageSendEvent_send_revoke_and_ack(int8_tArray node_id, uint64_t msg) {
50362 LDKPublicKey node_id_ref;
50363 CHECK(node_id->arr_len == 33);
50364 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50365 LDKRevokeAndACK msg_conv;
50366 msg_conv.inner = untag_ptr(msg);
50367 msg_conv.is_owned = ptr_is_owned(msg);
50368 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50369 msg_conv = RevokeAndACK_clone(&msg_conv);
50370 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50371 *ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
50372 uint64_t ret_ref = tag_ptr(ret_copy, true);
50376 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_closing_signed"))) TS_MessageSendEvent_send_closing_signed(int8_tArray node_id, uint64_t msg) {
50377 LDKPublicKey node_id_ref;
50378 CHECK(node_id->arr_len == 33);
50379 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50380 LDKClosingSigned msg_conv;
50381 msg_conv.inner = untag_ptr(msg);
50382 msg_conv.is_owned = ptr_is_owned(msg);
50383 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50384 msg_conv = ClosingSigned_clone(&msg_conv);
50385 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50386 *ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
50387 uint64_t ret_ref = tag_ptr(ret_copy, true);
50391 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_shutdown"))) TS_MessageSendEvent_send_shutdown(int8_tArray node_id, uint64_t msg) {
50392 LDKPublicKey node_id_ref;
50393 CHECK(node_id->arr_len == 33);
50394 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50395 LDKShutdown msg_conv;
50396 msg_conv.inner = untag_ptr(msg);
50397 msg_conv.is_owned = ptr_is_owned(msg);
50398 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50399 msg_conv = Shutdown_clone(&msg_conv);
50400 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50401 *ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
50402 uint64_t ret_ref = tag_ptr(ret_copy, true);
50406 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_reestablish"))) TS_MessageSendEvent_send_channel_reestablish(int8_tArray node_id, uint64_t msg) {
50407 LDKPublicKey node_id_ref;
50408 CHECK(node_id->arr_len == 33);
50409 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50410 LDKChannelReestablish msg_conv;
50411 msg_conv.inner = untag_ptr(msg);
50412 msg_conv.is_owned = ptr_is_owned(msg);
50413 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50414 msg_conv = ChannelReestablish_clone(&msg_conv);
50415 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50416 *ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
50417 uint64_t ret_ref = tag_ptr(ret_copy, true);
50421 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) {
50422 LDKPublicKey node_id_ref;
50423 CHECK(node_id->arr_len == 33);
50424 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50425 LDKChannelAnnouncement msg_conv;
50426 msg_conv.inner = untag_ptr(msg);
50427 msg_conv.is_owned = ptr_is_owned(msg);
50428 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50429 msg_conv = ChannelAnnouncement_clone(&msg_conv);
50430 LDKChannelUpdate update_msg_conv;
50431 update_msg_conv.inner = untag_ptr(update_msg);
50432 update_msg_conv.is_owned = ptr_is_owned(update_msg);
50433 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
50434 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
50435 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50436 *ret_copy = MessageSendEvent_send_channel_announcement(node_id_ref, msg_conv, update_msg_conv);
50437 uint64_t ret_ref = tag_ptr(ret_copy, true);
50441 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_announcement"))) TS_MessageSendEvent_broadcast_channel_announcement(uint64_t msg, uint64_t update_msg) {
50442 LDKChannelAnnouncement msg_conv;
50443 msg_conv.inner = untag_ptr(msg);
50444 msg_conv.is_owned = ptr_is_owned(msg);
50445 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50446 msg_conv = ChannelAnnouncement_clone(&msg_conv);
50447 LDKChannelUpdate update_msg_conv;
50448 update_msg_conv.inner = untag_ptr(update_msg);
50449 update_msg_conv.is_owned = ptr_is_owned(update_msg);
50450 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
50451 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
50452 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50453 *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
50454 uint64_t ret_ref = tag_ptr(ret_copy, true);
50458 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_update"))) TS_MessageSendEvent_broadcast_channel_update(uint64_t msg) {
50459 LDKChannelUpdate msg_conv;
50460 msg_conv.inner = untag_ptr(msg);
50461 msg_conv.is_owned = ptr_is_owned(msg);
50462 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50463 msg_conv = ChannelUpdate_clone(&msg_conv);
50464 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50465 *ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
50466 uint64_t ret_ref = tag_ptr(ret_copy, true);
50470 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_node_announcement"))) TS_MessageSendEvent_broadcast_node_announcement(uint64_t msg) {
50471 LDKNodeAnnouncement msg_conv;
50472 msg_conv.inner = untag_ptr(msg);
50473 msg_conv.is_owned = ptr_is_owned(msg);
50474 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50475 msg_conv = NodeAnnouncement_clone(&msg_conv);
50476 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50477 *ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
50478 uint64_t ret_ref = tag_ptr(ret_copy, true);
50482 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_update"))) TS_MessageSendEvent_send_channel_update(int8_tArray node_id, uint64_t msg) {
50483 LDKPublicKey node_id_ref;
50484 CHECK(node_id->arr_len == 33);
50485 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50486 LDKChannelUpdate msg_conv;
50487 msg_conv.inner = untag_ptr(msg);
50488 msg_conv.is_owned = ptr_is_owned(msg);
50489 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50490 msg_conv = ChannelUpdate_clone(&msg_conv);
50491 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50492 *ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
50493 uint64_t ret_ref = tag_ptr(ret_copy, true);
50497 uint64_t __attribute__((export_name("TS_MessageSendEvent_handle_error"))) TS_MessageSendEvent_handle_error(int8_tArray node_id, uint64_t action) {
50498 LDKPublicKey node_id_ref;
50499 CHECK(node_id->arr_len == 33);
50500 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50501 void* action_ptr = untag_ptr(action);
50502 CHECK_ACCESS(action_ptr);
50503 LDKErrorAction action_conv = *(LDKErrorAction*)(action_ptr);
50504 action_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action));
50505 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50506 *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv);
50507 uint64_t ret_ref = tag_ptr(ret_copy, true);
50511 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_range_query"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint64_t msg) {
50512 LDKPublicKey node_id_ref;
50513 CHECK(node_id->arr_len == 33);
50514 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50515 LDKQueryChannelRange msg_conv;
50516 msg_conv.inner = untag_ptr(msg);
50517 msg_conv.is_owned = ptr_is_owned(msg);
50518 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50519 msg_conv = QueryChannelRange_clone(&msg_conv);
50520 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50521 *ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
50522 uint64_t ret_ref = tag_ptr(ret_copy, true);
50526 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_short_ids_query"))) TS_MessageSendEvent_send_short_ids_query(int8_tArray node_id, uint64_t msg) {
50527 LDKPublicKey node_id_ref;
50528 CHECK(node_id->arr_len == 33);
50529 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50530 LDKQueryShortChannelIds msg_conv;
50531 msg_conv.inner = untag_ptr(msg);
50532 msg_conv.is_owned = ptr_is_owned(msg);
50533 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50534 msg_conv = QueryShortChannelIds_clone(&msg_conv);
50535 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50536 *ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
50537 uint64_t ret_ref = tag_ptr(ret_copy, true);
50541 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_reply_channel_range"))) TS_MessageSendEvent_send_reply_channel_range(int8_tArray node_id, uint64_t msg) {
50542 LDKPublicKey node_id_ref;
50543 CHECK(node_id->arr_len == 33);
50544 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50545 LDKReplyChannelRange msg_conv;
50546 msg_conv.inner = untag_ptr(msg);
50547 msg_conv.is_owned = ptr_is_owned(msg);
50548 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50549 msg_conv = ReplyChannelRange_clone(&msg_conv);
50550 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50551 *ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
50552 uint64_t ret_ref = tag_ptr(ret_copy, true);
50556 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_gossip_timestamp_filter"))) TS_MessageSendEvent_send_gossip_timestamp_filter(int8_tArray node_id, uint64_t msg) {
50557 LDKPublicKey node_id_ref;
50558 CHECK(node_id->arr_len == 33);
50559 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50560 LDKGossipTimestampFilter msg_conv;
50561 msg_conv.inner = untag_ptr(msg);
50562 msg_conv.is_owned = ptr_is_owned(msg);
50563 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50564 msg_conv = GossipTimestampFilter_clone(&msg_conv);
50565 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50566 *ret_copy = MessageSendEvent_send_gossip_timestamp_filter(node_id_ref, msg_conv);
50567 uint64_t ret_ref = tag_ptr(ret_copy, true);
50571 void __attribute__((export_name("TS_MessageSendEventsProvider_free"))) TS_MessageSendEventsProvider_free(uint64_t this_ptr) {
50572 if (!ptr_is_owned(this_ptr)) return;
50573 void* this_ptr_ptr = untag_ptr(this_ptr);
50574 CHECK_ACCESS(this_ptr_ptr);
50575 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(this_ptr_ptr);
50576 FREE(untag_ptr(this_ptr));
50577 MessageSendEventsProvider_free(this_ptr_conv);
50580 void __attribute__((export_name("TS_OnionMessageProvider_free"))) TS_OnionMessageProvider_free(uint64_t this_ptr) {
50581 if (!ptr_is_owned(this_ptr)) return;
50582 void* this_ptr_ptr = untag_ptr(this_ptr);
50583 CHECK_ACCESS(this_ptr_ptr);
50584 LDKOnionMessageProvider this_ptr_conv = *(LDKOnionMessageProvider*)(this_ptr_ptr);
50585 FREE(untag_ptr(this_ptr));
50586 OnionMessageProvider_free(this_ptr_conv);
50589 void __attribute__((export_name("TS_EventsProvider_free"))) TS_EventsProvider_free(uint64_t this_ptr) {
50590 if (!ptr_is_owned(this_ptr)) return;
50591 void* this_ptr_ptr = untag_ptr(this_ptr);
50592 CHECK_ACCESS(this_ptr_ptr);
50593 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(this_ptr_ptr);
50594 FREE(untag_ptr(this_ptr));
50595 EventsProvider_free(this_ptr_conv);
50598 void __attribute__((export_name("TS_EventHandler_free"))) TS_EventHandler_free(uint64_t this_ptr) {
50599 if (!ptr_is_owned(this_ptr)) return;
50600 void* this_ptr_ptr = untag_ptr(this_ptr);
50601 CHECK_ACCESS(this_ptr_ptr);
50602 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(this_ptr_ptr);
50603 FREE(untag_ptr(this_ptr));
50604 EventHandler_free(this_ptr_conv);
50607 void __attribute__((export_name("TS_GossipSync_free"))) TS_GossipSync_free(uint64_t this_ptr) {
50608 if (!ptr_is_owned(this_ptr)) return;
50609 void* this_ptr_ptr = untag_ptr(this_ptr);
50610 CHECK_ACCESS(this_ptr_ptr);
50611 LDKGossipSync this_ptr_conv = *(LDKGossipSync*)(this_ptr_ptr);
50612 FREE(untag_ptr(this_ptr));
50613 GossipSync_free(this_ptr_conv);
50616 uint64_t __attribute__((export_name("TS_GossipSync_p2_p"))) TS_GossipSync_p2_p(uint64_t a) {
50617 LDKP2PGossipSync a_conv;
50618 a_conv.inner = untag_ptr(a);
50619 a_conv.is_owned = ptr_is_owned(a);
50620 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50621 a_conv.is_owned = false;
50622 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
50623 *ret_copy = GossipSync_p2_p(&a_conv);
50624 uint64_t ret_ref = tag_ptr(ret_copy, true);
50628 uint64_t __attribute__((export_name("TS_GossipSync_rapid"))) TS_GossipSync_rapid(uint64_t a) {
50629 LDKRapidGossipSync a_conv;
50630 a_conv.inner = untag_ptr(a);
50631 a_conv.is_owned = ptr_is_owned(a);
50632 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50633 a_conv.is_owned = false;
50634 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
50635 *ret_copy = GossipSync_rapid(&a_conv);
50636 uint64_t ret_ref = tag_ptr(ret_copy, true);
50640 uint64_t __attribute__((export_name("TS_GossipSync_none"))) TS_GossipSync_none() {
50641 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
50642 *ret_copy = GossipSync_none();
50643 uint64_t ret_ref = tag_ptr(ret_copy, true);
50647 void __attribute__((export_name("TS_RapidGossipSync_free"))) TS_RapidGossipSync_free(uint64_t this_obj) {
50648 LDKRapidGossipSync this_obj_conv;
50649 this_obj_conv.inner = untag_ptr(this_obj);
50650 this_obj_conv.is_owned = ptr_is_owned(this_obj);
50651 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
50652 RapidGossipSync_free(this_obj_conv);
50655 uint64_t __attribute__((export_name("TS_RapidGossipSync_new"))) TS_RapidGossipSync_new(uint64_t network_graph, uint64_t logger) {
50656 LDKNetworkGraph network_graph_conv;
50657 network_graph_conv.inner = untag_ptr(network_graph);
50658 network_graph_conv.is_owned = ptr_is_owned(network_graph);
50659 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
50660 network_graph_conv.is_owned = false;
50661 void* logger_ptr = untag_ptr(logger);
50662 CHECK_ACCESS(logger_ptr);
50663 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
50664 if (logger_conv.free == LDKLogger_JCalls_free) {
50665 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
50666 LDKLogger_JCalls_cloned(&logger_conv);
50668 LDKRapidGossipSync ret_var = RapidGossipSync_new(&network_graph_conv, logger_conv);
50669 uint64_t ret_ref = 0;
50670 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
50671 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
50675 uint64_t __attribute__((export_name("TS_RapidGossipSync_update_network_graph_no_std"))) TS_RapidGossipSync_update_network_graph_no_std(uint64_t this_arg, int8_tArray update_data, uint64_t current_time_unix) {
50676 LDKRapidGossipSync this_arg_conv;
50677 this_arg_conv.inner = untag_ptr(this_arg);
50678 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50679 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50680 this_arg_conv.is_owned = false;
50681 LDKu8slice update_data_ref;
50682 update_data_ref.datalen = update_data->arr_len;
50683 update_data_ref.data = update_data->elems;
50684 void* current_time_unix_ptr = untag_ptr(current_time_unix);
50685 CHECK_ACCESS(current_time_unix_ptr);
50686 LDKCOption_u64Z current_time_unix_conv = *(LDKCOption_u64Z*)(current_time_unix_ptr);
50687 current_time_unix_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(current_time_unix));
50688 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
50689 *ret_conv = RapidGossipSync_update_network_graph_no_std(&this_arg_conv, update_data_ref, current_time_unix_conv);
50691 return tag_ptr(ret_conv, true);
50694 jboolean __attribute__((export_name("TS_RapidGossipSync_is_initial_sync_complete"))) TS_RapidGossipSync_is_initial_sync_complete(uint64_t this_arg) {
50695 LDKRapidGossipSync this_arg_conv;
50696 this_arg_conv.inner = untag_ptr(this_arg);
50697 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50698 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50699 this_arg_conv.is_owned = false;
50700 jboolean ret_conv = RapidGossipSync_is_initial_sync_complete(&this_arg_conv);
50704 void __attribute__((export_name("TS_GraphSyncError_free"))) TS_GraphSyncError_free(uint64_t this_ptr) {
50705 if (!ptr_is_owned(this_ptr)) return;
50706 void* this_ptr_ptr = untag_ptr(this_ptr);
50707 CHECK_ACCESS(this_ptr_ptr);
50708 LDKGraphSyncError this_ptr_conv = *(LDKGraphSyncError*)(this_ptr_ptr);
50709 FREE(untag_ptr(this_ptr));
50710 GraphSyncError_free(this_ptr_conv);
50713 static inline uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg) {
50714 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50715 *ret_copy = GraphSyncError_clone(arg);
50716 uint64_t ret_ref = tag_ptr(ret_copy, true);
50719 int64_t __attribute__((export_name("TS_GraphSyncError_clone_ptr"))) TS_GraphSyncError_clone_ptr(uint64_t arg) {
50720 LDKGraphSyncError* arg_conv = (LDKGraphSyncError*)untag_ptr(arg);
50721 int64_t ret_conv = GraphSyncError_clone_ptr(arg_conv);
50725 uint64_t __attribute__((export_name("TS_GraphSyncError_clone"))) TS_GraphSyncError_clone(uint64_t orig) {
50726 LDKGraphSyncError* orig_conv = (LDKGraphSyncError*)untag_ptr(orig);
50727 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50728 *ret_copy = GraphSyncError_clone(orig_conv);
50729 uint64_t ret_ref = tag_ptr(ret_copy, true);
50733 uint64_t __attribute__((export_name("TS_GraphSyncError_decode_error"))) TS_GraphSyncError_decode_error(uint64_t a) {
50734 void* a_ptr = untag_ptr(a);
50735 CHECK_ACCESS(a_ptr);
50736 LDKDecodeError a_conv = *(LDKDecodeError*)(a_ptr);
50737 a_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(a));
50738 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50739 *ret_copy = GraphSyncError_decode_error(a_conv);
50740 uint64_t ret_ref = tag_ptr(ret_copy, true);
50744 uint64_t __attribute__((export_name("TS_GraphSyncError_lightning_error"))) TS_GraphSyncError_lightning_error(uint64_t a) {
50745 LDKLightningError a_conv;
50746 a_conv.inner = untag_ptr(a);
50747 a_conv.is_owned = ptr_is_owned(a);
50748 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50749 a_conv = LightningError_clone(&a_conv);
50750 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50751 *ret_copy = GraphSyncError_lightning_error(a_conv);
50752 uint64_t ret_ref = tag_ptr(ret_copy, true);
50756 void __attribute__((export_name("TS_ParseError_free"))) TS_ParseError_free(uint64_t this_ptr) {
50757 if (!ptr_is_owned(this_ptr)) return;
50758 void* this_ptr_ptr = untag_ptr(this_ptr);
50759 CHECK_ACCESS(this_ptr_ptr);
50760 LDKParseError this_ptr_conv = *(LDKParseError*)(this_ptr_ptr);
50761 FREE(untag_ptr(this_ptr));
50762 ParseError_free(this_ptr_conv);
50765 static inline uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg) {
50766 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50767 *ret_copy = ParseError_clone(arg);
50768 uint64_t ret_ref = tag_ptr(ret_copy, true);
50771 int64_t __attribute__((export_name("TS_ParseError_clone_ptr"))) TS_ParseError_clone_ptr(uint64_t arg) {
50772 LDKParseError* arg_conv = (LDKParseError*)untag_ptr(arg);
50773 int64_t ret_conv = ParseError_clone_ptr(arg_conv);
50777 uint64_t __attribute__((export_name("TS_ParseError_clone"))) TS_ParseError_clone(uint64_t orig) {
50778 LDKParseError* orig_conv = (LDKParseError*)untag_ptr(orig);
50779 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50780 *ret_copy = ParseError_clone(orig_conv);
50781 uint64_t ret_ref = tag_ptr(ret_copy, true);
50785 uint64_t __attribute__((export_name("TS_ParseError_bech32_error"))) TS_ParseError_bech32_error(uint64_t a) {
50786 void* a_ptr = untag_ptr(a);
50787 CHECK_ACCESS(a_ptr);
50788 LDKBech32Error a_conv = *(LDKBech32Error*)(a_ptr);
50789 a_conv = Bech32Error_clone((LDKBech32Error*)untag_ptr(a));
50790 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50791 *ret_copy = ParseError_bech32_error(a_conv);
50792 uint64_t ret_ref = tag_ptr(ret_copy, true);
50796 uint64_t __attribute__((export_name("TS_ParseError_parse_amount_error"))) TS_ParseError_parse_amount_error(int32_t a) {
50798 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50799 *ret_copy = ParseError_parse_amount_error((LDKError){ ._dummy = 0 });
50800 uint64_t ret_ref = tag_ptr(ret_copy, true);
50804 uint64_t __attribute__((export_name("TS_ParseError_malformed_signature"))) TS_ParseError_malformed_signature(uint32_t a) {
50805 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
50806 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50807 *ret_copy = ParseError_malformed_signature(a_conv);
50808 uint64_t ret_ref = tag_ptr(ret_copy, true);
50812 uint64_t __attribute__((export_name("TS_ParseError_bad_prefix"))) TS_ParseError_bad_prefix() {
50813 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50814 *ret_copy = ParseError_bad_prefix();
50815 uint64_t ret_ref = tag_ptr(ret_copy, true);
50819 uint64_t __attribute__((export_name("TS_ParseError_unknown_currency"))) TS_ParseError_unknown_currency() {
50820 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50821 *ret_copy = ParseError_unknown_currency();
50822 uint64_t ret_ref = tag_ptr(ret_copy, true);
50826 uint64_t __attribute__((export_name("TS_ParseError_unknown_si_prefix"))) TS_ParseError_unknown_si_prefix() {
50827 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50828 *ret_copy = ParseError_unknown_si_prefix();
50829 uint64_t ret_ref = tag_ptr(ret_copy, true);
50833 uint64_t __attribute__((export_name("TS_ParseError_malformed_hrp"))) TS_ParseError_malformed_hrp() {
50834 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50835 *ret_copy = ParseError_malformed_hrp();
50836 uint64_t ret_ref = tag_ptr(ret_copy, true);
50840 uint64_t __attribute__((export_name("TS_ParseError_too_short_data_part"))) TS_ParseError_too_short_data_part() {
50841 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50842 *ret_copy = ParseError_too_short_data_part();
50843 uint64_t ret_ref = tag_ptr(ret_copy, true);
50847 uint64_t __attribute__((export_name("TS_ParseError_unexpected_end_of_tagged_fields"))) TS_ParseError_unexpected_end_of_tagged_fields() {
50848 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50849 *ret_copy = ParseError_unexpected_end_of_tagged_fields();
50850 uint64_t ret_ref = tag_ptr(ret_copy, true);
50854 uint64_t __attribute__((export_name("TS_ParseError_description_decode_error"))) TS_ParseError_description_decode_error(int32_t a) {
50856 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50857 *ret_copy = ParseError_description_decode_error((LDKError){ ._dummy = 0 });
50858 uint64_t ret_ref = tag_ptr(ret_copy, true);
50862 uint64_t __attribute__((export_name("TS_ParseError_padding_error"))) TS_ParseError_padding_error() {
50863 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50864 *ret_copy = ParseError_padding_error();
50865 uint64_t ret_ref = tag_ptr(ret_copy, true);
50869 uint64_t __attribute__((export_name("TS_ParseError_integer_overflow_error"))) TS_ParseError_integer_overflow_error() {
50870 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50871 *ret_copy = ParseError_integer_overflow_error();
50872 uint64_t ret_ref = tag_ptr(ret_copy, true);
50876 uint64_t __attribute__((export_name("TS_ParseError_invalid_seg_wit_program_length"))) TS_ParseError_invalid_seg_wit_program_length() {
50877 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50878 *ret_copy = ParseError_invalid_seg_wit_program_length();
50879 uint64_t ret_ref = tag_ptr(ret_copy, true);
50883 uint64_t __attribute__((export_name("TS_ParseError_invalid_pub_key_hash_length"))) TS_ParseError_invalid_pub_key_hash_length() {
50884 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50885 *ret_copy = ParseError_invalid_pub_key_hash_length();
50886 uint64_t ret_ref = tag_ptr(ret_copy, true);
50890 uint64_t __attribute__((export_name("TS_ParseError_invalid_script_hash_length"))) TS_ParseError_invalid_script_hash_length() {
50891 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50892 *ret_copy = ParseError_invalid_script_hash_length();
50893 uint64_t ret_ref = tag_ptr(ret_copy, true);
50897 uint64_t __attribute__((export_name("TS_ParseError_invalid_recovery_id"))) TS_ParseError_invalid_recovery_id() {
50898 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50899 *ret_copy = ParseError_invalid_recovery_id();
50900 uint64_t ret_ref = tag_ptr(ret_copy, true);
50904 uint64_t __attribute__((export_name("TS_ParseError_invalid_slice_length"))) TS_ParseError_invalid_slice_length(jstring a) {
50905 LDKStr a_conv = str_ref_to_owned_c(a);
50906 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50907 *ret_copy = ParseError_invalid_slice_length(a_conv);
50908 uint64_t ret_ref = tag_ptr(ret_copy, true);
50912 uint64_t __attribute__((export_name("TS_ParseError_skip"))) TS_ParseError_skip() {
50913 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50914 *ret_copy = ParseError_skip();
50915 uint64_t ret_ref = tag_ptr(ret_copy, true);
50919 jboolean __attribute__((export_name("TS_ParseError_eq"))) TS_ParseError_eq(uint64_t a, uint64_t b) {
50920 LDKParseError* a_conv = (LDKParseError*)untag_ptr(a);
50921 LDKParseError* b_conv = (LDKParseError*)untag_ptr(b);
50922 jboolean ret_conv = ParseError_eq(a_conv, b_conv);
50926 void __attribute__((export_name("TS_ParseOrSemanticError_free"))) TS_ParseOrSemanticError_free(uint64_t this_ptr) {
50927 if (!ptr_is_owned(this_ptr)) return;
50928 void* this_ptr_ptr = untag_ptr(this_ptr);
50929 CHECK_ACCESS(this_ptr_ptr);
50930 LDKParseOrSemanticError this_ptr_conv = *(LDKParseOrSemanticError*)(this_ptr_ptr);
50931 FREE(untag_ptr(this_ptr));
50932 ParseOrSemanticError_free(this_ptr_conv);
50935 static inline uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg) {
50936 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50937 *ret_copy = ParseOrSemanticError_clone(arg);
50938 uint64_t ret_ref = tag_ptr(ret_copy, true);
50941 int64_t __attribute__((export_name("TS_ParseOrSemanticError_clone_ptr"))) TS_ParseOrSemanticError_clone_ptr(uint64_t arg) {
50942 LDKParseOrSemanticError* arg_conv = (LDKParseOrSemanticError*)untag_ptr(arg);
50943 int64_t ret_conv = ParseOrSemanticError_clone_ptr(arg_conv);
50947 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_clone"))) TS_ParseOrSemanticError_clone(uint64_t orig) {
50948 LDKParseOrSemanticError* orig_conv = (LDKParseOrSemanticError*)untag_ptr(orig);
50949 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50950 *ret_copy = ParseOrSemanticError_clone(orig_conv);
50951 uint64_t ret_ref = tag_ptr(ret_copy, true);
50955 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_parse_error"))) TS_ParseOrSemanticError_parse_error(uint64_t a) {
50956 void* a_ptr = untag_ptr(a);
50957 CHECK_ACCESS(a_ptr);
50958 LDKParseError a_conv = *(LDKParseError*)(a_ptr);
50959 a_conv = ParseError_clone((LDKParseError*)untag_ptr(a));
50960 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50961 *ret_copy = ParseOrSemanticError_parse_error(a_conv);
50962 uint64_t ret_ref = tag_ptr(ret_copy, true);
50966 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_semantic_error"))) TS_ParseOrSemanticError_semantic_error(uint32_t a) {
50967 LDKSemanticError a_conv = LDKSemanticError_from_js(a);
50968 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50969 *ret_copy = ParseOrSemanticError_semantic_error(a_conv);
50970 uint64_t ret_ref = tag_ptr(ret_copy, true);
50974 jboolean __attribute__((export_name("TS_ParseOrSemanticError_eq"))) TS_ParseOrSemanticError_eq(uint64_t a, uint64_t b) {
50975 LDKParseOrSemanticError* a_conv = (LDKParseOrSemanticError*)untag_ptr(a);
50976 LDKParseOrSemanticError* b_conv = (LDKParseOrSemanticError*)untag_ptr(b);
50977 jboolean ret_conv = ParseOrSemanticError_eq(a_conv, b_conv);
50981 void __attribute__((export_name("TS_Invoice_free"))) TS_Invoice_free(uint64_t this_obj) {
50982 LDKInvoice this_obj_conv;
50983 this_obj_conv.inner = untag_ptr(this_obj);
50984 this_obj_conv.is_owned = ptr_is_owned(this_obj);
50985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
50986 Invoice_free(this_obj_conv);
50989 jboolean __attribute__((export_name("TS_Invoice_eq"))) TS_Invoice_eq(uint64_t a, uint64_t b) {
50991 a_conv.inner = untag_ptr(a);
50992 a_conv.is_owned = ptr_is_owned(a);
50993 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50994 a_conv.is_owned = false;
50996 b_conv.inner = untag_ptr(b);
50997 b_conv.is_owned = ptr_is_owned(b);
50998 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
50999 b_conv.is_owned = false;
51000 jboolean ret_conv = Invoice_eq(&a_conv, &b_conv);
51004 static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
51005 LDKInvoice ret_var = Invoice_clone(arg);
51006 uint64_t ret_ref = 0;
51007 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51008 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51011 int64_t __attribute__((export_name("TS_Invoice_clone_ptr"))) TS_Invoice_clone_ptr(uint64_t arg) {
51012 LDKInvoice arg_conv;
51013 arg_conv.inner = untag_ptr(arg);
51014 arg_conv.is_owned = ptr_is_owned(arg);
51015 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51016 arg_conv.is_owned = false;
51017 int64_t ret_conv = Invoice_clone_ptr(&arg_conv);
51021 uint64_t __attribute__((export_name("TS_Invoice_clone"))) TS_Invoice_clone(uint64_t orig) {
51022 LDKInvoice orig_conv;
51023 orig_conv.inner = untag_ptr(orig);
51024 orig_conv.is_owned = ptr_is_owned(orig);
51025 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51026 orig_conv.is_owned = false;
51027 LDKInvoice ret_var = Invoice_clone(&orig_conv);
51028 uint64_t ret_ref = 0;
51029 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51030 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51034 int64_t __attribute__((export_name("TS_Invoice_hash"))) TS_Invoice_hash(uint64_t o) {
51036 o_conv.inner = untag_ptr(o);
51037 o_conv.is_owned = ptr_is_owned(o);
51038 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51039 o_conv.is_owned = false;
51040 int64_t ret_conv = Invoice_hash(&o_conv);
51044 void __attribute__((export_name("TS_SignedRawInvoice_free"))) TS_SignedRawInvoice_free(uint64_t this_obj) {
51045 LDKSignedRawInvoice this_obj_conv;
51046 this_obj_conv.inner = untag_ptr(this_obj);
51047 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51048 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51049 SignedRawInvoice_free(this_obj_conv);
51052 jboolean __attribute__((export_name("TS_SignedRawInvoice_eq"))) TS_SignedRawInvoice_eq(uint64_t a, uint64_t b) {
51053 LDKSignedRawInvoice a_conv;
51054 a_conv.inner = untag_ptr(a);
51055 a_conv.is_owned = ptr_is_owned(a);
51056 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51057 a_conv.is_owned = false;
51058 LDKSignedRawInvoice b_conv;
51059 b_conv.inner = untag_ptr(b);
51060 b_conv.is_owned = ptr_is_owned(b);
51061 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51062 b_conv.is_owned = false;
51063 jboolean ret_conv = SignedRawInvoice_eq(&a_conv, &b_conv);
51067 static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
51068 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
51069 uint64_t ret_ref = 0;
51070 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51071 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51074 int64_t __attribute__((export_name("TS_SignedRawInvoice_clone_ptr"))) TS_SignedRawInvoice_clone_ptr(uint64_t arg) {
51075 LDKSignedRawInvoice arg_conv;
51076 arg_conv.inner = untag_ptr(arg);
51077 arg_conv.is_owned = ptr_is_owned(arg);
51078 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51079 arg_conv.is_owned = false;
51080 int64_t ret_conv = SignedRawInvoice_clone_ptr(&arg_conv);
51084 uint64_t __attribute__((export_name("TS_SignedRawInvoice_clone"))) TS_SignedRawInvoice_clone(uint64_t orig) {
51085 LDKSignedRawInvoice orig_conv;
51086 orig_conv.inner = untag_ptr(orig);
51087 orig_conv.is_owned = ptr_is_owned(orig);
51088 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51089 orig_conv.is_owned = false;
51090 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
51091 uint64_t ret_ref = 0;
51092 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51093 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51097 int64_t __attribute__((export_name("TS_SignedRawInvoice_hash"))) TS_SignedRawInvoice_hash(uint64_t o) {
51098 LDKSignedRawInvoice o_conv;
51099 o_conv.inner = untag_ptr(o);
51100 o_conv.is_owned = ptr_is_owned(o);
51101 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51102 o_conv.is_owned = false;
51103 int64_t ret_conv = SignedRawInvoice_hash(&o_conv);
51107 void __attribute__((export_name("TS_RawInvoice_free"))) TS_RawInvoice_free(uint64_t this_obj) {
51108 LDKRawInvoice this_obj_conv;
51109 this_obj_conv.inner = untag_ptr(this_obj);
51110 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51112 RawInvoice_free(this_obj_conv);
51115 uint64_t __attribute__((export_name("TS_RawInvoice_get_data"))) TS_RawInvoice_get_data(uint64_t this_ptr) {
51116 LDKRawInvoice this_ptr_conv;
51117 this_ptr_conv.inner = untag_ptr(this_ptr);
51118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51120 this_ptr_conv.is_owned = false;
51121 LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
51122 uint64_t ret_ref = 0;
51123 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51124 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51128 void __attribute__((export_name("TS_RawInvoice_set_data"))) TS_RawInvoice_set_data(uint64_t this_ptr, uint64_t val) {
51129 LDKRawInvoice this_ptr_conv;
51130 this_ptr_conv.inner = untag_ptr(this_ptr);
51131 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51133 this_ptr_conv.is_owned = false;
51134 LDKRawDataPart val_conv;
51135 val_conv.inner = untag_ptr(val);
51136 val_conv.is_owned = ptr_is_owned(val);
51137 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
51138 val_conv = RawDataPart_clone(&val_conv);
51139 RawInvoice_set_data(&this_ptr_conv, val_conv);
51142 jboolean __attribute__((export_name("TS_RawInvoice_eq"))) TS_RawInvoice_eq(uint64_t a, uint64_t b) {
51143 LDKRawInvoice a_conv;
51144 a_conv.inner = untag_ptr(a);
51145 a_conv.is_owned = ptr_is_owned(a);
51146 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51147 a_conv.is_owned = false;
51148 LDKRawInvoice b_conv;
51149 b_conv.inner = untag_ptr(b);
51150 b_conv.is_owned = ptr_is_owned(b);
51151 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51152 b_conv.is_owned = false;
51153 jboolean ret_conv = RawInvoice_eq(&a_conv, &b_conv);
51157 static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
51158 LDKRawInvoice ret_var = RawInvoice_clone(arg);
51159 uint64_t ret_ref = 0;
51160 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51161 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51164 int64_t __attribute__((export_name("TS_RawInvoice_clone_ptr"))) TS_RawInvoice_clone_ptr(uint64_t arg) {
51165 LDKRawInvoice arg_conv;
51166 arg_conv.inner = untag_ptr(arg);
51167 arg_conv.is_owned = ptr_is_owned(arg);
51168 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51169 arg_conv.is_owned = false;
51170 int64_t ret_conv = RawInvoice_clone_ptr(&arg_conv);
51174 uint64_t __attribute__((export_name("TS_RawInvoice_clone"))) TS_RawInvoice_clone(uint64_t orig) {
51175 LDKRawInvoice orig_conv;
51176 orig_conv.inner = untag_ptr(orig);
51177 orig_conv.is_owned = ptr_is_owned(orig);
51178 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51179 orig_conv.is_owned = false;
51180 LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
51181 uint64_t ret_ref = 0;
51182 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51183 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51187 int64_t __attribute__((export_name("TS_RawInvoice_hash"))) TS_RawInvoice_hash(uint64_t o) {
51188 LDKRawInvoice o_conv;
51189 o_conv.inner = untag_ptr(o);
51190 o_conv.is_owned = ptr_is_owned(o);
51191 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51192 o_conv.is_owned = false;
51193 int64_t ret_conv = RawInvoice_hash(&o_conv);
51197 void __attribute__((export_name("TS_RawDataPart_free"))) TS_RawDataPart_free(uint64_t this_obj) {
51198 LDKRawDataPart this_obj_conv;
51199 this_obj_conv.inner = untag_ptr(this_obj);
51200 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51201 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51202 RawDataPart_free(this_obj_conv);
51205 uint64_t __attribute__((export_name("TS_RawDataPart_get_timestamp"))) TS_RawDataPart_get_timestamp(uint64_t this_ptr) {
51206 LDKRawDataPart this_ptr_conv;
51207 this_ptr_conv.inner = untag_ptr(this_ptr);
51208 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51210 this_ptr_conv.is_owned = false;
51211 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
51212 uint64_t ret_ref = 0;
51213 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51214 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51218 void __attribute__((export_name("TS_RawDataPart_set_timestamp"))) TS_RawDataPart_set_timestamp(uint64_t this_ptr, uint64_t val) {
51219 LDKRawDataPart this_ptr_conv;
51220 this_ptr_conv.inner = untag_ptr(this_ptr);
51221 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51222 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51223 this_ptr_conv.is_owned = false;
51224 LDKPositiveTimestamp val_conv;
51225 val_conv.inner = untag_ptr(val);
51226 val_conv.is_owned = ptr_is_owned(val);
51227 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
51228 val_conv = PositiveTimestamp_clone(&val_conv);
51229 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
51232 jboolean __attribute__((export_name("TS_RawDataPart_eq"))) TS_RawDataPart_eq(uint64_t a, uint64_t b) {
51233 LDKRawDataPart a_conv;
51234 a_conv.inner = untag_ptr(a);
51235 a_conv.is_owned = ptr_is_owned(a);
51236 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51237 a_conv.is_owned = false;
51238 LDKRawDataPart b_conv;
51239 b_conv.inner = untag_ptr(b);
51240 b_conv.is_owned = ptr_is_owned(b);
51241 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51242 b_conv.is_owned = false;
51243 jboolean ret_conv = RawDataPart_eq(&a_conv, &b_conv);
51247 static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
51248 LDKRawDataPart ret_var = RawDataPart_clone(arg);
51249 uint64_t ret_ref = 0;
51250 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51251 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51254 int64_t __attribute__((export_name("TS_RawDataPart_clone_ptr"))) TS_RawDataPart_clone_ptr(uint64_t arg) {
51255 LDKRawDataPart arg_conv;
51256 arg_conv.inner = untag_ptr(arg);
51257 arg_conv.is_owned = ptr_is_owned(arg);
51258 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51259 arg_conv.is_owned = false;
51260 int64_t ret_conv = RawDataPart_clone_ptr(&arg_conv);
51264 uint64_t __attribute__((export_name("TS_RawDataPart_clone"))) TS_RawDataPart_clone(uint64_t orig) {
51265 LDKRawDataPart orig_conv;
51266 orig_conv.inner = untag_ptr(orig);
51267 orig_conv.is_owned = ptr_is_owned(orig);
51268 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51269 orig_conv.is_owned = false;
51270 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
51271 uint64_t ret_ref = 0;
51272 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51273 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51277 int64_t __attribute__((export_name("TS_RawDataPart_hash"))) TS_RawDataPart_hash(uint64_t o) {
51278 LDKRawDataPart o_conv;
51279 o_conv.inner = untag_ptr(o);
51280 o_conv.is_owned = ptr_is_owned(o);
51281 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51282 o_conv.is_owned = false;
51283 int64_t ret_conv = RawDataPart_hash(&o_conv);
51287 void __attribute__((export_name("TS_PositiveTimestamp_free"))) TS_PositiveTimestamp_free(uint64_t this_obj) {
51288 LDKPositiveTimestamp this_obj_conv;
51289 this_obj_conv.inner = untag_ptr(this_obj);
51290 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51292 PositiveTimestamp_free(this_obj_conv);
51295 jboolean __attribute__((export_name("TS_PositiveTimestamp_eq"))) TS_PositiveTimestamp_eq(uint64_t a, uint64_t b) {
51296 LDKPositiveTimestamp a_conv;
51297 a_conv.inner = untag_ptr(a);
51298 a_conv.is_owned = ptr_is_owned(a);
51299 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51300 a_conv.is_owned = false;
51301 LDKPositiveTimestamp b_conv;
51302 b_conv.inner = untag_ptr(b);
51303 b_conv.is_owned = ptr_is_owned(b);
51304 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51305 b_conv.is_owned = false;
51306 jboolean ret_conv = PositiveTimestamp_eq(&a_conv, &b_conv);
51310 static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
51311 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
51312 uint64_t ret_ref = 0;
51313 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51314 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51317 int64_t __attribute__((export_name("TS_PositiveTimestamp_clone_ptr"))) TS_PositiveTimestamp_clone_ptr(uint64_t arg) {
51318 LDKPositiveTimestamp arg_conv;
51319 arg_conv.inner = untag_ptr(arg);
51320 arg_conv.is_owned = ptr_is_owned(arg);
51321 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51322 arg_conv.is_owned = false;
51323 int64_t ret_conv = PositiveTimestamp_clone_ptr(&arg_conv);
51327 uint64_t __attribute__((export_name("TS_PositiveTimestamp_clone"))) TS_PositiveTimestamp_clone(uint64_t orig) {
51328 LDKPositiveTimestamp orig_conv;
51329 orig_conv.inner = untag_ptr(orig);
51330 orig_conv.is_owned = ptr_is_owned(orig);
51331 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51332 orig_conv.is_owned = false;
51333 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
51334 uint64_t ret_ref = 0;
51335 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51336 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51340 int64_t __attribute__((export_name("TS_PositiveTimestamp_hash"))) TS_PositiveTimestamp_hash(uint64_t o) {
51341 LDKPositiveTimestamp o_conv;
51342 o_conv.inner = untag_ptr(o);
51343 o_conv.is_owned = ptr_is_owned(o);
51344 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51345 o_conv.is_owned = false;
51346 int64_t ret_conv = PositiveTimestamp_hash(&o_conv);
51350 uint32_t __attribute__((export_name("TS_SiPrefix_clone"))) TS_SiPrefix_clone(uint64_t orig) {
51351 LDKSiPrefix* orig_conv = (LDKSiPrefix*)untag_ptr(orig);
51352 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_clone(orig_conv));
51356 uint32_t __attribute__((export_name("TS_SiPrefix_milli"))) TS_SiPrefix_milli() {
51357 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_milli());
51361 uint32_t __attribute__((export_name("TS_SiPrefix_micro"))) TS_SiPrefix_micro() {
51362 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_micro());
51366 uint32_t __attribute__((export_name("TS_SiPrefix_nano"))) TS_SiPrefix_nano() {
51367 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_nano());
51371 uint32_t __attribute__((export_name("TS_SiPrefix_pico"))) TS_SiPrefix_pico() {
51372 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_pico());
51376 jboolean __attribute__((export_name("TS_SiPrefix_eq"))) TS_SiPrefix_eq(uint64_t a, uint64_t b) {
51377 LDKSiPrefix* a_conv = (LDKSiPrefix*)untag_ptr(a);
51378 LDKSiPrefix* b_conv = (LDKSiPrefix*)untag_ptr(b);
51379 jboolean ret_conv = SiPrefix_eq(a_conv, b_conv);
51383 int64_t __attribute__((export_name("TS_SiPrefix_hash"))) TS_SiPrefix_hash(uint64_t o) {
51384 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
51385 int64_t ret_conv = SiPrefix_hash(o_conv);
51389 int64_t __attribute__((export_name("TS_SiPrefix_multiplier"))) TS_SiPrefix_multiplier(uint64_t this_arg) {
51390 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)untag_ptr(this_arg);
51391 int64_t ret_conv = SiPrefix_multiplier(this_arg_conv);
51395 uint32_t __attribute__((export_name("TS_Currency_clone"))) TS_Currency_clone(uint64_t orig) {
51396 LDKCurrency* orig_conv = (LDKCurrency*)untag_ptr(orig);
51397 uint32_t ret_conv = LDKCurrency_to_js(Currency_clone(orig_conv));
51401 uint32_t __attribute__((export_name("TS_Currency_bitcoin"))) TS_Currency_bitcoin() {
51402 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin());
51406 uint32_t __attribute__((export_name("TS_Currency_bitcoin_testnet"))) TS_Currency_bitcoin_testnet() {
51407 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin_testnet());
51411 uint32_t __attribute__((export_name("TS_Currency_regtest"))) TS_Currency_regtest() {
51412 uint32_t ret_conv = LDKCurrency_to_js(Currency_regtest());
51416 uint32_t __attribute__((export_name("TS_Currency_simnet"))) TS_Currency_simnet() {
51417 uint32_t ret_conv = LDKCurrency_to_js(Currency_simnet());
51421 uint32_t __attribute__((export_name("TS_Currency_signet"))) TS_Currency_signet() {
51422 uint32_t ret_conv = LDKCurrency_to_js(Currency_signet());
51426 int64_t __attribute__((export_name("TS_Currency_hash"))) TS_Currency_hash(uint64_t o) {
51427 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
51428 int64_t ret_conv = Currency_hash(o_conv);
51432 jboolean __attribute__((export_name("TS_Currency_eq"))) TS_Currency_eq(uint64_t a, uint64_t b) {
51433 LDKCurrency* a_conv = (LDKCurrency*)untag_ptr(a);
51434 LDKCurrency* b_conv = (LDKCurrency*)untag_ptr(b);
51435 jboolean ret_conv = Currency_eq(a_conv, b_conv);
51439 void __attribute__((export_name("TS_Sha256_free"))) TS_Sha256_free(uint64_t this_obj) {
51440 LDKSha256 this_obj_conv;
51441 this_obj_conv.inner = untag_ptr(this_obj);
51442 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51444 Sha256_free(this_obj_conv);
51447 static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
51448 LDKSha256 ret_var = Sha256_clone(arg);
51449 uint64_t ret_ref = 0;
51450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51451 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51454 int64_t __attribute__((export_name("TS_Sha256_clone_ptr"))) TS_Sha256_clone_ptr(uint64_t arg) {
51455 LDKSha256 arg_conv;
51456 arg_conv.inner = untag_ptr(arg);
51457 arg_conv.is_owned = ptr_is_owned(arg);
51458 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51459 arg_conv.is_owned = false;
51460 int64_t ret_conv = Sha256_clone_ptr(&arg_conv);
51464 uint64_t __attribute__((export_name("TS_Sha256_clone"))) TS_Sha256_clone(uint64_t orig) {
51465 LDKSha256 orig_conv;
51466 orig_conv.inner = untag_ptr(orig);
51467 orig_conv.is_owned = ptr_is_owned(orig);
51468 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51469 orig_conv.is_owned = false;
51470 LDKSha256 ret_var = Sha256_clone(&orig_conv);
51471 uint64_t ret_ref = 0;
51472 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51473 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51477 int64_t __attribute__((export_name("TS_Sha256_hash"))) TS_Sha256_hash(uint64_t o) {
51479 o_conv.inner = untag_ptr(o);
51480 o_conv.is_owned = ptr_is_owned(o);
51481 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51482 o_conv.is_owned = false;
51483 int64_t ret_conv = Sha256_hash(&o_conv);
51487 jboolean __attribute__((export_name("TS_Sha256_eq"))) TS_Sha256_eq(uint64_t a, uint64_t b) {
51489 a_conv.inner = untag_ptr(a);
51490 a_conv.is_owned = ptr_is_owned(a);
51491 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51492 a_conv.is_owned = false;
51494 b_conv.inner = untag_ptr(b);
51495 b_conv.is_owned = ptr_is_owned(b);
51496 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51497 b_conv.is_owned = false;
51498 jboolean ret_conv = Sha256_eq(&a_conv, &b_conv);
51502 uint64_t __attribute__((export_name("TS_Sha256_from_bytes"))) TS_Sha256_from_bytes(int8_tArray bytes) {
51503 uint8_t bytes_arr[32];
51504 CHECK(bytes->arr_len == 32);
51505 memcpy(bytes_arr, bytes->elems, 32); FREE(bytes);
51506 uint8_t (*bytes_ref)[32] = &bytes_arr;
51507 LDKSha256 ret_var = Sha256_from_bytes(bytes_ref);
51508 uint64_t ret_ref = 0;
51509 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51510 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51514 void __attribute__((export_name("TS_Description_free"))) TS_Description_free(uint64_t this_obj) {
51515 LDKDescription this_obj_conv;
51516 this_obj_conv.inner = untag_ptr(this_obj);
51517 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51518 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51519 Description_free(this_obj_conv);
51522 static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
51523 LDKDescription ret_var = Description_clone(arg);
51524 uint64_t ret_ref = 0;
51525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51526 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51529 int64_t __attribute__((export_name("TS_Description_clone_ptr"))) TS_Description_clone_ptr(uint64_t arg) {
51530 LDKDescription arg_conv;
51531 arg_conv.inner = untag_ptr(arg);
51532 arg_conv.is_owned = ptr_is_owned(arg);
51533 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51534 arg_conv.is_owned = false;
51535 int64_t ret_conv = Description_clone_ptr(&arg_conv);
51539 uint64_t __attribute__((export_name("TS_Description_clone"))) TS_Description_clone(uint64_t orig) {
51540 LDKDescription orig_conv;
51541 orig_conv.inner = untag_ptr(orig);
51542 orig_conv.is_owned = ptr_is_owned(orig);
51543 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51544 orig_conv.is_owned = false;
51545 LDKDescription ret_var = Description_clone(&orig_conv);
51546 uint64_t ret_ref = 0;
51547 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51548 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51552 int64_t __attribute__((export_name("TS_Description_hash"))) TS_Description_hash(uint64_t o) {
51553 LDKDescription o_conv;
51554 o_conv.inner = untag_ptr(o);
51555 o_conv.is_owned = ptr_is_owned(o);
51556 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51557 o_conv.is_owned = false;
51558 int64_t ret_conv = Description_hash(&o_conv);
51562 jboolean __attribute__((export_name("TS_Description_eq"))) TS_Description_eq(uint64_t a, uint64_t b) {
51563 LDKDescription a_conv;
51564 a_conv.inner = untag_ptr(a);
51565 a_conv.is_owned = ptr_is_owned(a);
51566 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51567 a_conv.is_owned = false;
51568 LDKDescription b_conv;
51569 b_conv.inner = untag_ptr(b);
51570 b_conv.is_owned = ptr_is_owned(b);
51571 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51572 b_conv.is_owned = false;
51573 jboolean ret_conv = Description_eq(&a_conv, &b_conv);
51577 void __attribute__((export_name("TS_PayeePubKey_free"))) TS_PayeePubKey_free(uint64_t this_obj) {
51578 LDKPayeePubKey this_obj_conv;
51579 this_obj_conv.inner = untag_ptr(this_obj);
51580 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51582 PayeePubKey_free(this_obj_conv);
51585 int8_tArray __attribute__((export_name("TS_PayeePubKey_get_a"))) TS_PayeePubKey_get_a(uint64_t this_ptr) {
51586 LDKPayeePubKey this_ptr_conv;
51587 this_ptr_conv.inner = untag_ptr(this_ptr);
51588 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51589 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51590 this_ptr_conv.is_owned = false;
51591 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
51592 memcpy(ret_arr->elems, PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
51596 void __attribute__((export_name("TS_PayeePubKey_set_a"))) TS_PayeePubKey_set_a(uint64_t this_ptr, int8_tArray val) {
51597 LDKPayeePubKey this_ptr_conv;
51598 this_ptr_conv.inner = untag_ptr(this_ptr);
51599 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51601 this_ptr_conv.is_owned = false;
51602 LDKPublicKey val_ref;
51603 CHECK(val->arr_len == 33);
51604 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
51605 PayeePubKey_set_a(&this_ptr_conv, val_ref);
51608 uint64_t __attribute__((export_name("TS_PayeePubKey_new"))) TS_PayeePubKey_new(int8_tArray a_arg) {
51609 LDKPublicKey a_arg_ref;
51610 CHECK(a_arg->arr_len == 33);
51611 memcpy(a_arg_ref.compressed_form, a_arg->elems, 33); FREE(a_arg);
51612 LDKPayeePubKey ret_var = PayeePubKey_new(a_arg_ref);
51613 uint64_t ret_ref = 0;
51614 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51615 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51619 static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
51620 LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
51621 uint64_t ret_ref = 0;
51622 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51623 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51626 int64_t __attribute__((export_name("TS_PayeePubKey_clone_ptr"))) TS_PayeePubKey_clone_ptr(uint64_t arg) {
51627 LDKPayeePubKey arg_conv;
51628 arg_conv.inner = untag_ptr(arg);
51629 arg_conv.is_owned = ptr_is_owned(arg);
51630 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51631 arg_conv.is_owned = false;
51632 int64_t ret_conv = PayeePubKey_clone_ptr(&arg_conv);
51636 uint64_t __attribute__((export_name("TS_PayeePubKey_clone"))) TS_PayeePubKey_clone(uint64_t orig) {
51637 LDKPayeePubKey orig_conv;
51638 orig_conv.inner = untag_ptr(orig);
51639 orig_conv.is_owned = ptr_is_owned(orig);
51640 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51641 orig_conv.is_owned = false;
51642 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
51643 uint64_t ret_ref = 0;
51644 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51645 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51649 int64_t __attribute__((export_name("TS_PayeePubKey_hash"))) TS_PayeePubKey_hash(uint64_t o) {
51650 LDKPayeePubKey o_conv;
51651 o_conv.inner = untag_ptr(o);
51652 o_conv.is_owned = ptr_is_owned(o);
51653 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51654 o_conv.is_owned = false;
51655 int64_t ret_conv = PayeePubKey_hash(&o_conv);
51659 jboolean __attribute__((export_name("TS_PayeePubKey_eq"))) TS_PayeePubKey_eq(uint64_t a, uint64_t b) {
51660 LDKPayeePubKey a_conv;
51661 a_conv.inner = untag_ptr(a);
51662 a_conv.is_owned = ptr_is_owned(a);
51663 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51664 a_conv.is_owned = false;
51665 LDKPayeePubKey b_conv;
51666 b_conv.inner = untag_ptr(b);
51667 b_conv.is_owned = ptr_is_owned(b);
51668 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51669 b_conv.is_owned = false;
51670 jboolean ret_conv = PayeePubKey_eq(&a_conv, &b_conv);
51674 void __attribute__((export_name("TS_ExpiryTime_free"))) TS_ExpiryTime_free(uint64_t this_obj) {
51675 LDKExpiryTime this_obj_conv;
51676 this_obj_conv.inner = untag_ptr(this_obj);
51677 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51678 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51679 ExpiryTime_free(this_obj_conv);
51682 static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
51683 LDKExpiryTime ret_var = ExpiryTime_clone(arg);
51684 uint64_t ret_ref = 0;
51685 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51686 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51689 int64_t __attribute__((export_name("TS_ExpiryTime_clone_ptr"))) TS_ExpiryTime_clone_ptr(uint64_t arg) {
51690 LDKExpiryTime arg_conv;
51691 arg_conv.inner = untag_ptr(arg);
51692 arg_conv.is_owned = ptr_is_owned(arg);
51693 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51694 arg_conv.is_owned = false;
51695 int64_t ret_conv = ExpiryTime_clone_ptr(&arg_conv);
51699 uint64_t __attribute__((export_name("TS_ExpiryTime_clone"))) TS_ExpiryTime_clone(uint64_t orig) {
51700 LDKExpiryTime orig_conv;
51701 orig_conv.inner = untag_ptr(orig);
51702 orig_conv.is_owned = ptr_is_owned(orig);
51703 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51704 orig_conv.is_owned = false;
51705 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
51706 uint64_t ret_ref = 0;
51707 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51708 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51712 int64_t __attribute__((export_name("TS_ExpiryTime_hash"))) TS_ExpiryTime_hash(uint64_t o) {
51713 LDKExpiryTime o_conv;
51714 o_conv.inner = untag_ptr(o);
51715 o_conv.is_owned = ptr_is_owned(o);
51716 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51717 o_conv.is_owned = false;
51718 int64_t ret_conv = ExpiryTime_hash(&o_conv);
51722 jboolean __attribute__((export_name("TS_ExpiryTime_eq"))) TS_ExpiryTime_eq(uint64_t a, uint64_t b) {
51723 LDKExpiryTime a_conv;
51724 a_conv.inner = untag_ptr(a);
51725 a_conv.is_owned = ptr_is_owned(a);
51726 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51727 a_conv.is_owned = false;
51728 LDKExpiryTime b_conv;
51729 b_conv.inner = untag_ptr(b);
51730 b_conv.is_owned = ptr_is_owned(b);
51731 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51732 b_conv.is_owned = false;
51733 jboolean ret_conv = ExpiryTime_eq(&a_conv, &b_conv);
51737 void __attribute__((export_name("TS_MinFinalCltvExpiryDelta_free"))) TS_MinFinalCltvExpiryDelta_free(uint64_t this_obj) {
51738 LDKMinFinalCltvExpiryDelta this_obj_conv;
51739 this_obj_conv.inner = untag_ptr(this_obj);
51740 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51742 MinFinalCltvExpiryDelta_free(this_obj_conv);
51745 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_get_a"))) TS_MinFinalCltvExpiryDelta_get_a(uint64_t this_ptr) {
51746 LDKMinFinalCltvExpiryDelta this_ptr_conv;
51747 this_ptr_conv.inner = untag_ptr(this_ptr);
51748 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51749 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51750 this_ptr_conv.is_owned = false;
51751 int64_t ret_conv = MinFinalCltvExpiryDelta_get_a(&this_ptr_conv);
51755 void __attribute__((export_name("TS_MinFinalCltvExpiryDelta_set_a"))) TS_MinFinalCltvExpiryDelta_set_a(uint64_t this_ptr, int64_t val) {
51756 LDKMinFinalCltvExpiryDelta this_ptr_conv;
51757 this_ptr_conv.inner = untag_ptr(this_ptr);
51758 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51759 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51760 this_ptr_conv.is_owned = false;
51761 MinFinalCltvExpiryDelta_set_a(&this_ptr_conv, val);
51764 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_new"))) TS_MinFinalCltvExpiryDelta_new(int64_t a_arg) {
51765 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_new(a_arg);
51766 uint64_t ret_ref = 0;
51767 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51768 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51772 static inline uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg) {
51773 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_clone(arg);
51774 uint64_t ret_ref = 0;
51775 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51776 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51779 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_clone_ptr"))) TS_MinFinalCltvExpiryDelta_clone_ptr(uint64_t arg) {
51780 LDKMinFinalCltvExpiryDelta arg_conv;
51781 arg_conv.inner = untag_ptr(arg);
51782 arg_conv.is_owned = ptr_is_owned(arg);
51783 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51784 arg_conv.is_owned = false;
51785 int64_t ret_conv = MinFinalCltvExpiryDelta_clone_ptr(&arg_conv);
51789 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_clone"))) TS_MinFinalCltvExpiryDelta_clone(uint64_t orig) {
51790 LDKMinFinalCltvExpiryDelta orig_conv;
51791 orig_conv.inner = untag_ptr(orig);
51792 orig_conv.is_owned = ptr_is_owned(orig);
51793 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51794 orig_conv.is_owned = false;
51795 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_clone(&orig_conv);
51796 uint64_t ret_ref = 0;
51797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51798 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51802 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_hash"))) TS_MinFinalCltvExpiryDelta_hash(uint64_t o) {
51803 LDKMinFinalCltvExpiryDelta o_conv;
51804 o_conv.inner = untag_ptr(o);
51805 o_conv.is_owned = ptr_is_owned(o);
51806 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51807 o_conv.is_owned = false;
51808 int64_t ret_conv = MinFinalCltvExpiryDelta_hash(&o_conv);
51812 jboolean __attribute__((export_name("TS_MinFinalCltvExpiryDelta_eq"))) TS_MinFinalCltvExpiryDelta_eq(uint64_t a, uint64_t b) {
51813 LDKMinFinalCltvExpiryDelta a_conv;
51814 a_conv.inner = untag_ptr(a);
51815 a_conv.is_owned = ptr_is_owned(a);
51816 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51817 a_conv.is_owned = false;
51818 LDKMinFinalCltvExpiryDelta b_conv;
51819 b_conv.inner = untag_ptr(b);
51820 b_conv.is_owned = ptr_is_owned(b);
51821 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51822 b_conv.is_owned = false;
51823 jboolean ret_conv = MinFinalCltvExpiryDelta_eq(&a_conv, &b_conv);
51827 void __attribute__((export_name("TS_Fallback_free"))) TS_Fallback_free(uint64_t this_ptr) {
51828 if (!ptr_is_owned(this_ptr)) return;
51829 void* this_ptr_ptr = untag_ptr(this_ptr);
51830 CHECK_ACCESS(this_ptr_ptr);
51831 LDKFallback this_ptr_conv = *(LDKFallback*)(this_ptr_ptr);
51832 FREE(untag_ptr(this_ptr));
51833 Fallback_free(this_ptr_conv);
51836 static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
51837 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51838 *ret_copy = Fallback_clone(arg);
51839 uint64_t ret_ref = tag_ptr(ret_copy, true);
51842 int64_t __attribute__((export_name("TS_Fallback_clone_ptr"))) TS_Fallback_clone_ptr(uint64_t arg) {
51843 LDKFallback* arg_conv = (LDKFallback*)untag_ptr(arg);
51844 int64_t ret_conv = Fallback_clone_ptr(arg_conv);
51848 uint64_t __attribute__((export_name("TS_Fallback_clone"))) TS_Fallback_clone(uint64_t orig) {
51849 LDKFallback* orig_conv = (LDKFallback*)untag_ptr(orig);
51850 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51851 *ret_copy = Fallback_clone(orig_conv);
51852 uint64_t ret_ref = tag_ptr(ret_copy, true);
51856 uint64_t __attribute__((export_name("TS_Fallback_seg_wit_program"))) TS_Fallback_seg_wit_program(int8_t version, int8_tArray program) {
51858 LDKCVec_u8Z program_ref;
51859 program_ref.datalen = program->arr_len;
51860 program_ref.data = MALLOC(program_ref.datalen, "LDKCVec_u8Z Bytes");
51861 memcpy(program_ref.data, program->elems, program_ref.datalen); FREE(program);
51862 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51863 *ret_copy = Fallback_seg_wit_program((LDKWitnessVersion){ ._0 = version }, program_ref);
51864 uint64_t ret_ref = tag_ptr(ret_copy, true);
51868 uint64_t __attribute__((export_name("TS_Fallback_pub_key_hash"))) TS_Fallback_pub_key_hash(int8_tArray a) {
51869 LDKTwentyBytes a_ref;
51870 CHECK(a->arr_len == 20);
51871 memcpy(a_ref.data, a->elems, 20); FREE(a);
51872 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51873 *ret_copy = Fallback_pub_key_hash(a_ref);
51874 uint64_t ret_ref = tag_ptr(ret_copy, true);
51878 uint64_t __attribute__((export_name("TS_Fallback_script_hash"))) TS_Fallback_script_hash(int8_tArray a) {
51879 LDKTwentyBytes a_ref;
51880 CHECK(a->arr_len == 20);
51881 memcpy(a_ref.data, a->elems, 20); FREE(a);
51882 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51883 *ret_copy = Fallback_script_hash(a_ref);
51884 uint64_t ret_ref = tag_ptr(ret_copy, true);
51888 int64_t __attribute__((export_name("TS_Fallback_hash"))) TS_Fallback_hash(uint64_t o) {
51889 LDKFallback* o_conv = (LDKFallback*)untag_ptr(o);
51890 int64_t ret_conv = Fallback_hash(o_conv);
51894 jboolean __attribute__((export_name("TS_Fallback_eq"))) TS_Fallback_eq(uint64_t a, uint64_t b) {
51895 LDKFallback* a_conv = (LDKFallback*)untag_ptr(a);
51896 LDKFallback* b_conv = (LDKFallback*)untag_ptr(b);
51897 jboolean ret_conv = Fallback_eq(a_conv, b_conv);
51901 void __attribute__((export_name("TS_InvoiceSignature_free"))) TS_InvoiceSignature_free(uint64_t this_obj) {
51902 LDKInvoiceSignature this_obj_conv;
51903 this_obj_conv.inner = untag_ptr(this_obj);
51904 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51906 InvoiceSignature_free(this_obj_conv);
51909 static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
51910 LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
51911 uint64_t ret_ref = 0;
51912 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51913 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51916 int64_t __attribute__((export_name("TS_InvoiceSignature_clone_ptr"))) TS_InvoiceSignature_clone_ptr(uint64_t arg) {
51917 LDKInvoiceSignature arg_conv;
51918 arg_conv.inner = untag_ptr(arg);
51919 arg_conv.is_owned = ptr_is_owned(arg);
51920 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51921 arg_conv.is_owned = false;
51922 int64_t ret_conv = InvoiceSignature_clone_ptr(&arg_conv);
51926 uint64_t __attribute__((export_name("TS_InvoiceSignature_clone"))) TS_InvoiceSignature_clone(uint64_t orig) {
51927 LDKInvoiceSignature orig_conv;
51928 orig_conv.inner = untag_ptr(orig);
51929 orig_conv.is_owned = ptr_is_owned(orig);
51930 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51931 orig_conv.is_owned = false;
51932 LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
51933 uint64_t ret_ref = 0;
51934 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51935 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51939 int64_t __attribute__((export_name("TS_InvoiceSignature_hash"))) TS_InvoiceSignature_hash(uint64_t o) {
51940 LDKInvoiceSignature o_conv;
51941 o_conv.inner = untag_ptr(o);
51942 o_conv.is_owned = ptr_is_owned(o);
51943 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51944 o_conv.is_owned = false;
51945 int64_t ret_conv = InvoiceSignature_hash(&o_conv);
51949 jboolean __attribute__((export_name("TS_InvoiceSignature_eq"))) TS_InvoiceSignature_eq(uint64_t a, uint64_t b) {
51950 LDKInvoiceSignature a_conv;
51951 a_conv.inner = untag_ptr(a);
51952 a_conv.is_owned = ptr_is_owned(a);
51953 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51954 a_conv.is_owned = false;
51955 LDKInvoiceSignature b_conv;
51956 b_conv.inner = untag_ptr(b);
51957 b_conv.is_owned = ptr_is_owned(b);
51958 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51959 b_conv.is_owned = false;
51960 jboolean ret_conv = InvoiceSignature_eq(&a_conv, &b_conv);
51964 void __attribute__((export_name("TS_PrivateRoute_free"))) TS_PrivateRoute_free(uint64_t this_obj) {
51965 LDKPrivateRoute this_obj_conv;
51966 this_obj_conv.inner = untag_ptr(this_obj);
51967 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51969 PrivateRoute_free(this_obj_conv);
51972 static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
51973 LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
51974 uint64_t ret_ref = 0;
51975 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51976 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51979 int64_t __attribute__((export_name("TS_PrivateRoute_clone_ptr"))) TS_PrivateRoute_clone_ptr(uint64_t arg) {
51980 LDKPrivateRoute arg_conv;
51981 arg_conv.inner = untag_ptr(arg);
51982 arg_conv.is_owned = ptr_is_owned(arg);
51983 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51984 arg_conv.is_owned = false;
51985 int64_t ret_conv = PrivateRoute_clone_ptr(&arg_conv);
51989 uint64_t __attribute__((export_name("TS_PrivateRoute_clone"))) TS_PrivateRoute_clone(uint64_t orig) {
51990 LDKPrivateRoute orig_conv;
51991 orig_conv.inner = untag_ptr(orig);
51992 orig_conv.is_owned = ptr_is_owned(orig);
51993 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51994 orig_conv.is_owned = false;
51995 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
51996 uint64_t ret_ref = 0;
51997 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51998 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52002 int64_t __attribute__((export_name("TS_PrivateRoute_hash"))) TS_PrivateRoute_hash(uint64_t o) {
52003 LDKPrivateRoute o_conv;
52004 o_conv.inner = untag_ptr(o);
52005 o_conv.is_owned = ptr_is_owned(o);
52006 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
52007 o_conv.is_owned = false;
52008 int64_t ret_conv = PrivateRoute_hash(&o_conv);
52012 jboolean __attribute__((export_name("TS_PrivateRoute_eq"))) TS_PrivateRoute_eq(uint64_t a, uint64_t b) {
52013 LDKPrivateRoute a_conv;
52014 a_conv.inner = untag_ptr(a);
52015 a_conv.is_owned = ptr_is_owned(a);
52016 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
52017 a_conv.is_owned = false;
52018 LDKPrivateRoute b_conv;
52019 b_conv.inner = untag_ptr(b);
52020 b_conv.is_owned = ptr_is_owned(b);
52021 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
52022 b_conv.is_owned = false;
52023 jboolean ret_conv = PrivateRoute_eq(&a_conv, &b_conv);
52027 uint64_t __attribute__((export_name("TS_SignedRawInvoice_into_parts"))) TS_SignedRawInvoice_into_parts(uint64_t this_arg) {
52028 LDKSignedRawInvoice this_arg_conv;
52029 this_arg_conv.inner = untag_ptr(this_arg);
52030 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52032 this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
52033 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
52034 *ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
52035 return tag_ptr(ret_conv, true);
52038 uint64_t __attribute__((export_name("TS_SignedRawInvoice_raw_invoice"))) TS_SignedRawInvoice_raw_invoice(uint64_t this_arg) {
52039 LDKSignedRawInvoice this_arg_conv;
52040 this_arg_conv.inner = untag_ptr(this_arg);
52041 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52042 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52043 this_arg_conv.is_owned = false;
52044 LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
52045 uint64_t ret_ref = 0;
52046 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52047 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52051 int8_tArray __attribute__((export_name("TS_SignedRawInvoice_signable_hash"))) TS_SignedRawInvoice_signable_hash(uint64_t this_arg) {
52052 LDKSignedRawInvoice this_arg_conv;
52053 this_arg_conv.inner = untag_ptr(this_arg);
52054 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52056 this_arg_conv.is_owned = false;
52057 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52058 memcpy(ret_arr->elems, *SignedRawInvoice_signable_hash(&this_arg_conv), 32);
52062 uint64_t __attribute__((export_name("TS_SignedRawInvoice_signature"))) TS_SignedRawInvoice_signature(uint64_t this_arg) {
52063 LDKSignedRawInvoice this_arg_conv;
52064 this_arg_conv.inner = untag_ptr(this_arg);
52065 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52067 this_arg_conv.is_owned = false;
52068 LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
52069 uint64_t ret_ref = 0;
52070 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52071 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52075 uint64_t __attribute__((export_name("TS_SignedRawInvoice_recover_payee_pub_key"))) TS_SignedRawInvoice_recover_payee_pub_key(uint64_t this_arg) {
52076 LDKSignedRawInvoice this_arg_conv;
52077 this_arg_conv.inner = untag_ptr(this_arg);
52078 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52080 this_arg_conv.is_owned = false;
52081 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
52082 *ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
52083 return tag_ptr(ret_conv, true);
52086 jboolean __attribute__((export_name("TS_SignedRawInvoice_check_signature"))) TS_SignedRawInvoice_check_signature(uint64_t this_arg) {
52087 LDKSignedRawInvoice this_arg_conv;
52088 this_arg_conv.inner = untag_ptr(this_arg);
52089 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52090 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52091 this_arg_conv.is_owned = false;
52092 jboolean ret_conv = SignedRawInvoice_check_signature(&this_arg_conv);
52096 int8_tArray __attribute__((export_name("TS_RawInvoice_signable_hash"))) TS_RawInvoice_signable_hash(uint64_t this_arg) {
52097 LDKRawInvoice this_arg_conv;
52098 this_arg_conv.inner = untag_ptr(this_arg);
52099 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52101 this_arg_conv.is_owned = false;
52102 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52103 memcpy(ret_arr->elems, RawInvoice_signable_hash(&this_arg_conv).data, 32);
52107 uint64_t __attribute__((export_name("TS_RawInvoice_payment_hash"))) TS_RawInvoice_payment_hash(uint64_t this_arg) {
52108 LDKRawInvoice this_arg_conv;
52109 this_arg_conv.inner = untag_ptr(this_arg);
52110 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52112 this_arg_conv.is_owned = false;
52113 LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
52114 uint64_t ret_ref = 0;
52115 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52116 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52120 uint64_t __attribute__((export_name("TS_RawInvoice_description"))) TS_RawInvoice_description(uint64_t this_arg) {
52121 LDKRawInvoice this_arg_conv;
52122 this_arg_conv.inner = untag_ptr(this_arg);
52123 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52124 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52125 this_arg_conv.is_owned = false;
52126 LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
52127 uint64_t ret_ref = 0;
52128 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52129 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52133 uint64_t __attribute__((export_name("TS_RawInvoice_payee_pub_key"))) TS_RawInvoice_payee_pub_key(uint64_t this_arg) {
52134 LDKRawInvoice this_arg_conv;
52135 this_arg_conv.inner = untag_ptr(this_arg);
52136 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52137 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52138 this_arg_conv.is_owned = false;
52139 LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
52140 uint64_t ret_ref = 0;
52141 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52142 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52146 uint64_t __attribute__((export_name("TS_RawInvoice_description_hash"))) TS_RawInvoice_description_hash(uint64_t this_arg) {
52147 LDKRawInvoice this_arg_conv;
52148 this_arg_conv.inner = untag_ptr(this_arg);
52149 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52151 this_arg_conv.is_owned = false;
52152 LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
52153 uint64_t ret_ref = 0;
52154 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52155 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52159 uint64_t __attribute__((export_name("TS_RawInvoice_expiry_time"))) TS_RawInvoice_expiry_time(uint64_t this_arg) {
52160 LDKRawInvoice this_arg_conv;
52161 this_arg_conv.inner = untag_ptr(this_arg);
52162 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52164 this_arg_conv.is_owned = false;
52165 LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
52166 uint64_t ret_ref = 0;
52167 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52168 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52172 uint64_t __attribute__((export_name("TS_RawInvoice_min_final_cltv_expiry_delta"))) TS_RawInvoice_min_final_cltv_expiry_delta(uint64_t this_arg) {
52173 LDKRawInvoice this_arg_conv;
52174 this_arg_conv.inner = untag_ptr(this_arg);
52175 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52177 this_arg_conv.is_owned = false;
52178 LDKMinFinalCltvExpiryDelta ret_var = RawInvoice_min_final_cltv_expiry_delta(&this_arg_conv);
52179 uint64_t ret_ref = 0;
52180 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52181 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52185 int8_tArray __attribute__((export_name("TS_RawInvoice_payment_secret"))) TS_RawInvoice_payment_secret(uint64_t this_arg) {
52186 LDKRawInvoice this_arg_conv;
52187 this_arg_conv.inner = untag_ptr(this_arg);
52188 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52189 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52190 this_arg_conv.is_owned = false;
52191 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52192 memcpy(ret_arr->elems, RawInvoice_payment_secret(&this_arg_conv).data, 32);
52196 uint64_t __attribute__((export_name("TS_RawInvoice_payment_metadata"))) TS_RawInvoice_payment_metadata(uint64_t this_arg) {
52197 LDKRawInvoice this_arg_conv;
52198 this_arg_conv.inner = untag_ptr(this_arg);
52199 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52200 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52201 this_arg_conv.is_owned = false;
52202 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
52203 *ret_copy = RawInvoice_payment_metadata(&this_arg_conv);
52204 uint64_t ret_ref = tag_ptr(ret_copy, true);
52208 uint64_t __attribute__((export_name("TS_RawInvoice_features"))) TS_RawInvoice_features(uint64_t this_arg) {
52209 LDKRawInvoice this_arg_conv;
52210 this_arg_conv.inner = untag_ptr(this_arg);
52211 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52212 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52213 this_arg_conv.is_owned = false;
52214 LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
52215 uint64_t ret_ref = 0;
52216 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52217 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52221 uint64_tArray __attribute__((export_name("TS_RawInvoice_private_routes"))) TS_RawInvoice_private_routes(uint64_t this_arg) {
52222 LDKRawInvoice this_arg_conv;
52223 this_arg_conv.inner = untag_ptr(this_arg);
52224 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52226 this_arg_conv.is_owned = false;
52227 LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
52228 uint64_tArray ret_arr = NULL;
52229 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52230 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52231 for (size_t o = 0; o < ret_var.datalen; o++) {
52232 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
52233 uint64_t ret_conv_14_ref = 0;
52234 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
52235 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
52236 ret_arr_ptr[o] = ret_conv_14_ref;
52239 FREE(ret_var.data);
52243 uint64_t __attribute__((export_name("TS_RawInvoice_amount_pico_btc"))) TS_RawInvoice_amount_pico_btc(uint64_t this_arg) {
52244 LDKRawInvoice this_arg_conv;
52245 this_arg_conv.inner = untag_ptr(this_arg);
52246 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52248 this_arg_conv.is_owned = false;
52249 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
52250 *ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
52251 uint64_t ret_ref = tag_ptr(ret_copy, true);
52255 uint32_t __attribute__((export_name("TS_RawInvoice_currency"))) TS_RawInvoice_currency(uint64_t this_arg) {
52256 LDKRawInvoice this_arg_conv;
52257 this_arg_conv.inner = untag_ptr(this_arg);
52258 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52260 this_arg_conv.is_owned = false;
52261 uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
52265 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_unix_timestamp"))) TS_PositiveTimestamp_from_unix_timestamp(int64_t unix_seconds) {
52266 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
52267 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
52268 return tag_ptr(ret_conv, true);
52271 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_duration_since_epoch"))) TS_PositiveTimestamp_from_duration_since_epoch(int64_t duration) {
52272 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
52273 *ret_conv = PositiveTimestamp_from_duration_since_epoch(duration);
52274 return tag_ptr(ret_conv, true);
52277 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_unix_timestamp"))) TS_PositiveTimestamp_as_unix_timestamp(uint64_t this_arg) {
52278 LDKPositiveTimestamp this_arg_conv;
52279 this_arg_conv.inner = untag_ptr(this_arg);
52280 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52282 this_arg_conv.is_owned = false;
52283 int64_t ret_conv = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
52287 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_duration_since_epoch"))) TS_PositiveTimestamp_as_duration_since_epoch(uint64_t this_arg) {
52288 LDKPositiveTimestamp this_arg_conv;
52289 this_arg_conv.inner = untag_ptr(this_arg);
52290 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52292 this_arg_conv.is_owned = false;
52293 int64_t ret_conv = PositiveTimestamp_as_duration_since_epoch(&this_arg_conv);
52297 int8_tArray __attribute__((export_name("TS_Invoice_signable_hash"))) TS_Invoice_signable_hash(uint64_t this_arg) {
52298 LDKInvoice this_arg_conv;
52299 this_arg_conv.inner = untag_ptr(this_arg);
52300 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52301 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52302 this_arg_conv.is_owned = false;
52303 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52304 memcpy(ret_arr->elems, Invoice_signable_hash(&this_arg_conv).data, 32);
52308 uint64_t __attribute__((export_name("TS_Invoice_into_signed_raw"))) TS_Invoice_into_signed_raw(uint64_t this_arg) {
52309 LDKInvoice this_arg_conv;
52310 this_arg_conv.inner = untag_ptr(this_arg);
52311 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52312 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52313 this_arg_conv = Invoice_clone(&this_arg_conv);
52314 LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
52315 uint64_t ret_ref = 0;
52316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52321 uint64_t __attribute__((export_name("TS_Invoice_check_signature"))) TS_Invoice_check_signature(uint64_t this_arg) {
52322 LDKInvoice this_arg_conv;
52323 this_arg_conv.inner = untag_ptr(this_arg);
52324 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52326 this_arg_conv.is_owned = false;
52327 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
52328 *ret_conv = Invoice_check_signature(&this_arg_conv);
52329 return tag_ptr(ret_conv, true);
52332 uint64_t __attribute__((export_name("TS_Invoice_from_signed"))) TS_Invoice_from_signed(uint64_t signed_invoice) {
52333 LDKSignedRawInvoice signed_invoice_conv;
52334 signed_invoice_conv.inner = untag_ptr(signed_invoice);
52335 signed_invoice_conv.is_owned = ptr_is_owned(signed_invoice);
52336 CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
52337 signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
52338 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
52339 *ret_conv = Invoice_from_signed(signed_invoice_conv);
52340 return tag_ptr(ret_conv, true);
52343 int64_t __attribute__((export_name("TS_Invoice_duration_since_epoch"))) TS_Invoice_duration_since_epoch(uint64_t this_arg) {
52344 LDKInvoice this_arg_conv;
52345 this_arg_conv.inner = untag_ptr(this_arg);
52346 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52348 this_arg_conv.is_owned = false;
52349 int64_t ret_conv = Invoice_duration_since_epoch(&this_arg_conv);
52353 int8_tArray __attribute__((export_name("TS_Invoice_payment_hash"))) TS_Invoice_payment_hash(uint64_t this_arg) {
52354 LDKInvoice this_arg_conv;
52355 this_arg_conv.inner = untag_ptr(this_arg);
52356 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52357 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52358 this_arg_conv.is_owned = false;
52359 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52360 memcpy(ret_arr->elems, *Invoice_payment_hash(&this_arg_conv), 32);
52364 int8_tArray __attribute__((export_name("TS_Invoice_payee_pub_key"))) TS_Invoice_payee_pub_key(uint64_t this_arg) {
52365 LDKInvoice this_arg_conv;
52366 this_arg_conv.inner = untag_ptr(this_arg);
52367 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52368 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52369 this_arg_conv.is_owned = false;
52370 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
52371 memcpy(ret_arr->elems, Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
52375 int8_tArray __attribute__((export_name("TS_Invoice_payment_secret"))) TS_Invoice_payment_secret(uint64_t this_arg) {
52376 LDKInvoice this_arg_conv;
52377 this_arg_conv.inner = untag_ptr(this_arg);
52378 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52379 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52380 this_arg_conv.is_owned = false;
52381 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52382 memcpy(ret_arr->elems, *Invoice_payment_secret(&this_arg_conv), 32);
52386 uint64_t __attribute__((export_name("TS_Invoice_payment_metadata"))) TS_Invoice_payment_metadata(uint64_t this_arg) {
52387 LDKInvoice this_arg_conv;
52388 this_arg_conv.inner = untag_ptr(this_arg);
52389 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52390 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52391 this_arg_conv.is_owned = false;
52392 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
52393 *ret_copy = Invoice_payment_metadata(&this_arg_conv);
52394 uint64_t ret_ref = tag_ptr(ret_copy, true);
52398 uint64_t __attribute__((export_name("TS_Invoice_features"))) TS_Invoice_features(uint64_t this_arg) {
52399 LDKInvoice this_arg_conv;
52400 this_arg_conv.inner = untag_ptr(this_arg);
52401 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52402 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52403 this_arg_conv.is_owned = false;
52404 LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
52405 uint64_t ret_ref = 0;
52406 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52407 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52411 int8_tArray __attribute__((export_name("TS_Invoice_recover_payee_pub_key"))) TS_Invoice_recover_payee_pub_key(uint64_t this_arg) {
52412 LDKInvoice this_arg_conv;
52413 this_arg_conv.inner = untag_ptr(this_arg);
52414 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52415 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52416 this_arg_conv.is_owned = false;
52417 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
52418 memcpy(ret_arr->elems, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
52422 uint64_t __attribute__((export_name("TS_Invoice_expires_at"))) TS_Invoice_expires_at(uint64_t this_arg) {
52423 LDKInvoice this_arg_conv;
52424 this_arg_conv.inner = untag_ptr(this_arg);
52425 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52427 this_arg_conv.is_owned = false;
52428 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
52429 *ret_copy = Invoice_expires_at(&this_arg_conv);
52430 uint64_t ret_ref = tag_ptr(ret_copy, true);
52434 int64_t __attribute__((export_name("TS_Invoice_expiry_time"))) TS_Invoice_expiry_time(uint64_t this_arg) {
52435 LDKInvoice this_arg_conv;
52436 this_arg_conv.inner = untag_ptr(this_arg);
52437 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52439 this_arg_conv.is_owned = false;
52440 int64_t ret_conv = Invoice_expiry_time(&this_arg_conv);
52444 int64_t __attribute__((export_name("TS_Invoice_expiration_remaining_from_epoch"))) TS_Invoice_expiration_remaining_from_epoch(uint64_t this_arg, int64_t time) {
52445 LDKInvoice this_arg_conv;
52446 this_arg_conv.inner = untag_ptr(this_arg);
52447 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52448 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52449 this_arg_conv.is_owned = false;
52450 int64_t ret_conv = Invoice_expiration_remaining_from_epoch(&this_arg_conv, time);
52454 jboolean __attribute__((export_name("TS_Invoice_would_expire"))) TS_Invoice_would_expire(uint64_t this_arg, int64_t at_time) {
52455 LDKInvoice this_arg_conv;
52456 this_arg_conv.inner = untag_ptr(this_arg);
52457 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52459 this_arg_conv.is_owned = false;
52460 jboolean ret_conv = Invoice_would_expire(&this_arg_conv, at_time);
52464 int64_t __attribute__((export_name("TS_Invoice_min_final_cltv_expiry_delta"))) TS_Invoice_min_final_cltv_expiry_delta(uint64_t this_arg) {
52465 LDKInvoice this_arg_conv;
52466 this_arg_conv.inner = untag_ptr(this_arg);
52467 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52469 this_arg_conv.is_owned = false;
52470 int64_t ret_conv = Invoice_min_final_cltv_expiry_delta(&this_arg_conv);
52474 ptrArray __attribute__((export_name("TS_Invoice_fallback_addresses"))) TS_Invoice_fallback_addresses(uint64_t this_arg) {
52475 LDKInvoice this_arg_conv;
52476 this_arg_conv.inner = untag_ptr(this_arg);
52477 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52478 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52479 this_arg_conv.is_owned = false;
52480 LDKCVec_AddressZ ret_var = Invoice_fallback_addresses(&this_arg_conv);
52481 ptrArray ret_arr = NULL;
52482 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
52483 jstring *ret_arr_ptr = (jstring*)(((uint8_t*)ret_arr) + 8);
52484 for (size_t i = 0; i < ret_var.datalen; i++) {
52485 LDKStr ret_conv_8_str = ret_var.data[i];
52486 jstring ret_conv_8_conv = str_ref_to_ts(ret_conv_8_str.chars, ret_conv_8_str.len);
52487 Str_free(ret_conv_8_str);
52488 ret_arr_ptr[i] = ret_conv_8_conv;
52491 FREE(ret_var.data);
52495 uint64_tArray __attribute__((export_name("TS_Invoice_private_routes"))) TS_Invoice_private_routes(uint64_t this_arg) {
52496 LDKInvoice this_arg_conv;
52497 this_arg_conv.inner = untag_ptr(this_arg);
52498 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52499 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52500 this_arg_conv.is_owned = false;
52501 LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
52502 uint64_tArray ret_arr = NULL;
52503 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52504 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52505 for (size_t o = 0; o < ret_var.datalen; o++) {
52506 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
52507 uint64_t ret_conv_14_ref = 0;
52508 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
52509 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
52510 ret_arr_ptr[o] = ret_conv_14_ref;
52513 FREE(ret_var.data);
52517 uint64_tArray __attribute__((export_name("TS_Invoice_route_hints"))) TS_Invoice_route_hints(uint64_t this_arg) {
52518 LDKInvoice this_arg_conv;
52519 this_arg_conv.inner = untag_ptr(this_arg);
52520 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52521 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52522 this_arg_conv.is_owned = false;
52523 LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
52524 uint64_tArray ret_arr = NULL;
52525 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52526 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52527 for (size_t l = 0; l < ret_var.datalen; l++) {
52528 LDKRouteHint ret_conv_11_var = ret_var.data[l];
52529 uint64_t ret_conv_11_ref = 0;
52530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
52531 ret_conv_11_ref = tag_ptr(ret_conv_11_var.inner, ret_conv_11_var.is_owned);
52532 ret_arr_ptr[l] = ret_conv_11_ref;
52535 FREE(ret_var.data);
52539 uint32_t __attribute__((export_name("TS_Invoice_currency"))) TS_Invoice_currency(uint64_t this_arg) {
52540 LDKInvoice this_arg_conv;
52541 this_arg_conv.inner = untag_ptr(this_arg);
52542 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52543 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52544 this_arg_conv.is_owned = false;
52545 uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
52549 uint64_t __attribute__((export_name("TS_Invoice_amount_milli_satoshis"))) TS_Invoice_amount_milli_satoshis(uint64_t this_arg) {
52550 LDKInvoice this_arg_conv;
52551 this_arg_conv.inner = untag_ptr(this_arg);
52552 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52554 this_arg_conv.is_owned = false;
52555 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
52556 *ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
52557 uint64_t ret_ref = tag_ptr(ret_copy, true);
52561 uint64_t __attribute__((export_name("TS_Description_new"))) TS_Description_new(jstring description) {
52562 LDKStr description_conv = str_ref_to_owned_c(description);
52563 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
52564 *ret_conv = Description_new(description_conv);
52565 return tag_ptr(ret_conv, true);
52568 jstring __attribute__((export_name("TS_Description_into_inner"))) TS_Description_into_inner(uint64_t this_arg) {
52569 LDKDescription this_arg_conv;
52570 this_arg_conv.inner = untag_ptr(this_arg);
52571 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52573 this_arg_conv = Description_clone(&this_arg_conv);
52574 LDKStr ret_str = Description_into_inner(this_arg_conv);
52575 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52580 uint64_t __attribute__((export_name("TS_ExpiryTime_from_seconds"))) TS_ExpiryTime_from_seconds(int64_t seconds) {
52581 LDKExpiryTime ret_var = ExpiryTime_from_seconds(seconds);
52582 uint64_t ret_ref = 0;
52583 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52584 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52588 uint64_t __attribute__((export_name("TS_ExpiryTime_from_duration"))) TS_ExpiryTime_from_duration(int64_t duration) {
52589 LDKExpiryTime ret_var = ExpiryTime_from_duration(duration);
52590 uint64_t ret_ref = 0;
52591 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52592 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52596 int64_t __attribute__((export_name("TS_ExpiryTime_as_seconds"))) TS_ExpiryTime_as_seconds(uint64_t this_arg) {
52597 LDKExpiryTime this_arg_conv;
52598 this_arg_conv.inner = untag_ptr(this_arg);
52599 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52601 this_arg_conv.is_owned = false;
52602 int64_t ret_conv = ExpiryTime_as_seconds(&this_arg_conv);
52606 int64_t __attribute__((export_name("TS_ExpiryTime_as_duration"))) TS_ExpiryTime_as_duration(uint64_t this_arg) {
52607 LDKExpiryTime this_arg_conv;
52608 this_arg_conv.inner = untag_ptr(this_arg);
52609 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52611 this_arg_conv.is_owned = false;
52612 int64_t ret_conv = ExpiryTime_as_duration(&this_arg_conv);
52616 uint64_t __attribute__((export_name("TS_PrivateRoute_new"))) TS_PrivateRoute_new(uint64_t hops) {
52617 LDKRouteHint hops_conv;
52618 hops_conv.inner = untag_ptr(hops);
52619 hops_conv.is_owned = ptr_is_owned(hops);
52620 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
52621 hops_conv = RouteHint_clone(&hops_conv);
52622 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
52623 *ret_conv = PrivateRoute_new(hops_conv);
52624 return tag_ptr(ret_conv, true);
52627 uint64_t __attribute__((export_name("TS_PrivateRoute_into_inner"))) TS_PrivateRoute_into_inner(uint64_t this_arg) {
52628 LDKPrivateRoute this_arg_conv;
52629 this_arg_conv.inner = untag_ptr(this_arg);
52630 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52632 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
52633 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
52634 uint64_t ret_ref = 0;
52635 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52636 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52640 uint32_t __attribute__((export_name("TS_CreationError_clone"))) TS_CreationError_clone(uint64_t orig) {
52641 LDKCreationError* orig_conv = (LDKCreationError*)untag_ptr(orig);
52642 uint32_t ret_conv = LDKCreationError_to_js(CreationError_clone(orig_conv));
52646 uint32_t __attribute__((export_name("TS_CreationError_description_too_long"))) TS_CreationError_description_too_long() {
52647 uint32_t ret_conv = LDKCreationError_to_js(CreationError_description_too_long());
52651 uint32_t __attribute__((export_name("TS_CreationError_route_too_long"))) TS_CreationError_route_too_long() {
52652 uint32_t ret_conv = LDKCreationError_to_js(CreationError_route_too_long());
52656 uint32_t __attribute__((export_name("TS_CreationError_timestamp_out_of_bounds"))) TS_CreationError_timestamp_out_of_bounds() {
52657 uint32_t ret_conv = LDKCreationError_to_js(CreationError_timestamp_out_of_bounds());
52661 uint32_t __attribute__((export_name("TS_CreationError_invalid_amount"))) TS_CreationError_invalid_amount() {
52662 uint32_t ret_conv = LDKCreationError_to_js(CreationError_invalid_amount());
52666 uint32_t __attribute__((export_name("TS_CreationError_missing_route_hints"))) TS_CreationError_missing_route_hints() {
52667 uint32_t ret_conv = LDKCreationError_to_js(CreationError_missing_route_hints());
52671 uint32_t __attribute__((export_name("TS_CreationError_min_final_cltv_expiry_delta_too_short"))) TS_CreationError_min_final_cltv_expiry_delta_too_short() {
52672 uint32_t ret_conv = LDKCreationError_to_js(CreationError_min_final_cltv_expiry_delta_too_short());
52676 jboolean __attribute__((export_name("TS_CreationError_eq"))) TS_CreationError_eq(uint64_t a, uint64_t b) {
52677 LDKCreationError* a_conv = (LDKCreationError*)untag_ptr(a);
52678 LDKCreationError* b_conv = (LDKCreationError*)untag_ptr(b);
52679 jboolean ret_conv = CreationError_eq(a_conv, b_conv);
52683 jstring __attribute__((export_name("TS_CreationError_to_str"))) TS_CreationError_to_str(uint64_t o) {
52684 LDKCreationError* o_conv = (LDKCreationError*)untag_ptr(o);
52685 LDKStr ret_str = CreationError_to_str(o_conv);
52686 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52691 uint32_t __attribute__((export_name("TS_SemanticError_clone"))) TS_SemanticError_clone(uint64_t orig) {
52692 LDKSemanticError* orig_conv = (LDKSemanticError*)untag_ptr(orig);
52693 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_clone(orig_conv));
52697 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_hash"))) TS_SemanticError_no_payment_hash() {
52698 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_hash());
52702 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_hashes"))) TS_SemanticError_multiple_payment_hashes() {
52703 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_hashes());
52707 uint32_t __attribute__((export_name("TS_SemanticError_no_description"))) TS_SemanticError_no_description() {
52708 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_description());
52712 uint32_t __attribute__((export_name("TS_SemanticError_multiple_descriptions"))) TS_SemanticError_multiple_descriptions() {
52713 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_descriptions());
52717 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_secret"))) TS_SemanticError_no_payment_secret() {
52718 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_secret());
52722 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_secrets"))) TS_SemanticError_multiple_payment_secrets() {
52723 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_secrets());
52727 uint32_t __attribute__((export_name("TS_SemanticError_invalid_features"))) TS_SemanticError_invalid_features() {
52728 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_features());
52732 uint32_t __attribute__((export_name("TS_SemanticError_invalid_recovery_id"))) TS_SemanticError_invalid_recovery_id() {
52733 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_recovery_id());
52737 uint32_t __attribute__((export_name("TS_SemanticError_invalid_signature"))) TS_SemanticError_invalid_signature() {
52738 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_signature());
52742 uint32_t __attribute__((export_name("TS_SemanticError_imprecise_amount"))) TS_SemanticError_imprecise_amount() {
52743 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_imprecise_amount());
52747 jboolean __attribute__((export_name("TS_SemanticError_eq"))) TS_SemanticError_eq(uint64_t a, uint64_t b) {
52748 LDKSemanticError* a_conv = (LDKSemanticError*)untag_ptr(a);
52749 LDKSemanticError* b_conv = (LDKSemanticError*)untag_ptr(b);
52750 jboolean ret_conv = SemanticError_eq(a_conv, b_conv);
52754 jstring __attribute__((export_name("TS_SemanticError_to_str"))) TS_SemanticError_to_str(uint64_t o) {
52755 LDKSemanticError* o_conv = (LDKSemanticError*)untag_ptr(o);
52756 LDKStr ret_str = SemanticError_to_str(o_conv);
52757 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52762 void __attribute__((export_name("TS_SignOrCreationError_free"))) TS_SignOrCreationError_free(uint64_t this_ptr) {
52763 if (!ptr_is_owned(this_ptr)) return;
52764 void* this_ptr_ptr = untag_ptr(this_ptr);
52765 CHECK_ACCESS(this_ptr_ptr);
52766 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(this_ptr_ptr);
52767 FREE(untag_ptr(this_ptr));
52768 SignOrCreationError_free(this_ptr_conv);
52771 static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
52772 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52773 *ret_copy = SignOrCreationError_clone(arg);
52774 uint64_t ret_ref = tag_ptr(ret_copy, true);
52777 int64_t __attribute__((export_name("TS_SignOrCreationError_clone_ptr"))) TS_SignOrCreationError_clone_ptr(uint64_t arg) {
52778 LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)untag_ptr(arg);
52779 int64_t ret_conv = SignOrCreationError_clone_ptr(arg_conv);
52783 uint64_t __attribute__((export_name("TS_SignOrCreationError_clone"))) TS_SignOrCreationError_clone(uint64_t orig) {
52784 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)untag_ptr(orig);
52785 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52786 *ret_copy = SignOrCreationError_clone(orig_conv);
52787 uint64_t ret_ref = tag_ptr(ret_copy, true);
52791 uint64_t __attribute__((export_name("TS_SignOrCreationError_sign_error"))) TS_SignOrCreationError_sign_error() {
52792 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52793 *ret_copy = SignOrCreationError_sign_error();
52794 uint64_t ret_ref = tag_ptr(ret_copy, true);
52798 uint64_t __attribute__((export_name("TS_SignOrCreationError_creation_error"))) TS_SignOrCreationError_creation_error(uint32_t a) {
52799 LDKCreationError a_conv = LDKCreationError_from_js(a);
52800 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52801 *ret_copy = SignOrCreationError_creation_error(a_conv);
52802 uint64_t ret_ref = tag_ptr(ret_copy, true);
52806 jboolean __attribute__((export_name("TS_SignOrCreationError_eq"))) TS_SignOrCreationError_eq(uint64_t a, uint64_t b) {
52807 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)untag_ptr(a);
52808 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)untag_ptr(b);
52809 jboolean ret_conv = SignOrCreationError_eq(a_conv, b_conv);
52813 jstring __attribute__((export_name("TS_SignOrCreationError_to_str"))) TS_SignOrCreationError_to_str(uint64_t o) {
52814 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)untag_ptr(o);
52815 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
52816 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52821 uint64_t __attribute__((export_name("TS_pay_invoice"))) TS_pay_invoice(uint64_t invoice, uint64_t retry_strategy, uint64_t channelmanager) {
52822 LDKInvoice invoice_conv;
52823 invoice_conv.inner = untag_ptr(invoice);
52824 invoice_conv.is_owned = ptr_is_owned(invoice);
52825 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52826 invoice_conv.is_owned = false;
52827 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52828 CHECK_ACCESS(retry_strategy_ptr);
52829 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52830 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52831 LDKChannelManager channelmanager_conv;
52832 channelmanager_conv.inner = untag_ptr(channelmanager);
52833 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52834 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52835 channelmanager_conv.is_owned = false;
52836 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
52837 *ret_conv = pay_invoice(&invoice_conv, retry_strategy_conv, &channelmanager_conv);
52838 return tag_ptr(ret_conv, true);
52841 uint64_t __attribute__((export_name("TS_pay_invoice_with_id"))) TS_pay_invoice_with_id(uint64_t invoice, int8_tArray payment_id, uint64_t retry_strategy, uint64_t channelmanager) {
52842 LDKInvoice invoice_conv;
52843 invoice_conv.inner = untag_ptr(invoice);
52844 invoice_conv.is_owned = ptr_is_owned(invoice);
52845 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52846 invoice_conv.is_owned = false;
52847 LDKThirtyTwoBytes payment_id_ref;
52848 CHECK(payment_id->arr_len == 32);
52849 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
52850 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52851 CHECK_ACCESS(retry_strategy_ptr);
52852 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52853 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52854 LDKChannelManager channelmanager_conv;
52855 channelmanager_conv.inner = untag_ptr(channelmanager);
52856 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52857 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52858 channelmanager_conv.is_owned = false;
52859 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
52860 *ret_conv = pay_invoice_with_id(&invoice_conv, payment_id_ref, retry_strategy_conv, &channelmanager_conv);
52861 return tag_ptr(ret_conv, true);
52864 uint64_t __attribute__((export_name("TS_pay_zero_value_invoice"))) TS_pay_zero_value_invoice(uint64_t invoice, int64_t amount_msats, uint64_t retry_strategy, uint64_t channelmanager) {
52865 LDKInvoice invoice_conv;
52866 invoice_conv.inner = untag_ptr(invoice);
52867 invoice_conv.is_owned = ptr_is_owned(invoice);
52868 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52869 invoice_conv.is_owned = false;
52870 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52871 CHECK_ACCESS(retry_strategy_ptr);
52872 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52873 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52874 LDKChannelManager channelmanager_conv;
52875 channelmanager_conv.inner = untag_ptr(channelmanager);
52876 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52877 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52878 channelmanager_conv.is_owned = false;
52879 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
52880 *ret_conv = pay_zero_value_invoice(&invoice_conv, amount_msats, retry_strategy_conv, &channelmanager_conv);
52881 return tag_ptr(ret_conv, true);
52884 uint64_t __attribute__((export_name("TS_pay_zero_value_invoice_with_id"))) TS_pay_zero_value_invoice_with_id(uint64_t invoice, int64_t amount_msats, int8_tArray payment_id, uint64_t retry_strategy, uint64_t channelmanager) {
52885 LDKInvoice invoice_conv;
52886 invoice_conv.inner = untag_ptr(invoice);
52887 invoice_conv.is_owned = ptr_is_owned(invoice);
52888 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52889 invoice_conv.is_owned = false;
52890 LDKThirtyTwoBytes payment_id_ref;
52891 CHECK(payment_id->arr_len == 32);
52892 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
52893 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52894 CHECK_ACCESS(retry_strategy_ptr);
52895 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52896 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52897 LDKChannelManager channelmanager_conv;
52898 channelmanager_conv.inner = untag_ptr(channelmanager);
52899 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52900 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52901 channelmanager_conv.is_owned = false;
52902 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
52903 *ret_conv = pay_zero_value_invoice_with_id(&invoice_conv, amount_msats, payment_id_ref, retry_strategy_conv, &channelmanager_conv);
52904 return tag_ptr(ret_conv, true);
52907 void __attribute__((export_name("TS_PaymentError_free"))) TS_PaymentError_free(uint64_t this_ptr) {
52908 if (!ptr_is_owned(this_ptr)) return;
52909 void* this_ptr_ptr = untag_ptr(this_ptr);
52910 CHECK_ACCESS(this_ptr_ptr);
52911 LDKPaymentError this_ptr_conv = *(LDKPaymentError*)(this_ptr_ptr);
52912 FREE(untag_ptr(this_ptr));
52913 PaymentError_free(this_ptr_conv);
52916 static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
52917 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52918 *ret_copy = PaymentError_clone(arg);
52919 uint64_t ret_ref = tag_ptr(ret_copy, true);
52922 int64_t __attribute__((export_name("TS_PaymentError_clone_ptr"))) TS_PaymentError_clone_ptr(uint64_t arg) {
52923 LDKPaymentError* arg_conv = (LDKPaymentError*)untag_ptr(arg);
52924 int64_t ret_conv = PaymentError_clone_ptr(arg_conv);
52928 uint64_t __attribute__((export_name("TS_PaymentError_clone"))) TS_PaymentError_clone(uint64_t orig) {
52929 LDKPaymentError* orig_conv = (LDKPaymentError*)untag_ptr(orig);
52930 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52931 *ret_copy = PaymentError_clone(orig_conv);
52932 uint64_t ret_ref = tag_ptr(ret_copy, true);
52936 uint64_t __attribute__((export_name("TS_PaymentError_invoice"))) TS_PaymentError_invoice(jstring a) {
52937 LDKStr a_conv = str_ref_to_owned_c(a);
52938 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52939 *ret_copy = PaymentError_invoice(a_conv);
52940 uint64_t ret_ref = tag_ptr(ret_copy, true);
52944 uint64_t __attribute__((export_name("TS_PaymentError_sending"))) TS_PaymentError_sending(uint32_t a) {
52945 LDKRetryableSendFailure a_conv = LDKRetryableSendFailure_from_js(a);
52946 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52947 *ret_copy = PaymentError_sending(a_conv);
52948 uint64_t ret_ref = tag_ptr(ret_copy, true);
52952 uint64_t __attribute__((export_name("TS_create_phantom_invoice"))) TS_create_phantom_invoice(uint64_t amt_msat, int8_tArray payment_hash, jstring description, int32_t invoice_expiry_delta_secs, uint64_tArray phantom_route_hints, uint64_t entropy_source, uint64_t node_signer, uint64_t logger, uint32_t network, uint64_t min_final_cltv_expiry_delta, int64_t duration_since_epoch) {
52953 void* amt_msat_ptr = untag_ptr(amt_msat);
52954 CHECK_ACCESS(amt_msat_ptr);
52955 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
52956 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
52957 LDKThirtyTwoBytes payment_hash_ref;
52958 CHECK(payment_hash->arr_len == 32);
52959 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
52960 LDKStr description_conv = str_ref_to_owned_c(description);
52961 LDKCVec_PhantomRouteHintsZ phantom_route_hints_constr;
52962 phantom_route_hints_constr.datalen = phantom_route_hints->arr_len;
52963 if (phantom_route_hints_constr.datalen > 0)
52964 phantom_route_hints_constr.data = MALLOC(phantom_route_hints_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
52966 phantom_route_hints_constr.data = NULL;
52967 uint64_t* phantom_route_hints_vals = phantom_route_hints->elems;
52968 for (size_t t = 0; t < phantom_route_hints_constr.datalen; t++) {
52969 uint64_t phantom_route_hints_conv_19 = phantom_route_hints_vals[t];
52970 LDKPhantomRouteHints phantom_route_hints_conv_19_conv;
52971 phantom_route_hints_conv_19_conv.inner = untag_ptr(phantom_route_hints_conv_19);
52972 phantom_route_hints_conv_19_conv.is_owned = ptr_is_owned(phantom_route_hints_conv_19);
52973 CHECK_INNER_FIELD_ACCESS_OR_NULL(phantom_route_hints_conv_19_conv);
52974 phantom_route_hints_conv_19_conv = PhantomRouteHints_clone(&phantom_route_hints_conv_19_conv);
52975 phantom_route_hints_constr.data[t] = phantom_route_hints_conv_19_conv;
52977 FREE(phantom_route_hints);
52978 void* entropy_source_ptr = untag_ptr(entropy_source);
52979 CHECK_ACCESS(entropy_source_ptr);
52980 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
52981 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
52982 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
52983 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
52985 void* node_signer_ptr = untag_ptr(node_signer);
52986 CHECK_ACCESS(node_signer_ptr);
52987 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
52988 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
52989 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
52990 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
52992 void* logger_ptr = untag_ptr(logger);
52993 CHECK_ACCESS(logger_ptr);
52994 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
52995 if (logger_conv.free == LDKLogger_JCalls_free) {
52996 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
52997 LDKLogger_JCalls_cloned(&logger_conv);
52999 LDKCurrency network_conv = LDKCurrency_from_js(network);
53000 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53001 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53002 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53003 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53004 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53005 *ret_conv = create_phantom_invoice(amt_msat_conv, payment_hash_ref, description_conv, invoice_expiry_delta_secs, phantom_route_hints_constr, entropy_source_conv, node_signer_conv, logger_conv, network_conv, min_final_cltv_expiry_delta_conv, duration_since_epoch);
53006 return tag_ptr(ret_conv, true);
53009 uint64_t __attribute__((export_name("TS_create_phantom_invoice_with_description_hash"))) TS_create_phantom_invoice_with_description_hash(uint64_t amt_msat, int8_tArray payment_hash, int32_t invoice_expiry_delta_secs, uint64_t description_hash, uint64_tArray phantom_route_hints, uint64_t entropy_source, uint64_t node_signer, uint64_t logger, uint32_t network, uint64_t min_final_cltv_expiry_delta, int64_t duration_since_epoch) {
53010 void* amt_msat_ptr = untag_ptr(amt_msat);
53011 CHECK_ACCESS(amt_msat_ptr);
53012 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53013 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53014 LDKThirtyTwoBytes payment_hash_ref;
53015 CHECK(payment_hash->arr_len == 32);
53016 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
53017 LDKSha256 description_hash_conv;
53018 description_hash_conv.inner = untag_ptr(description_hash);
53019 description_hash_conv.is_owned = ptr_is_owned(description_hash);
53020 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
53021 description_hash_conv = Sha256_clone(&description_hash_conv);
53022 LDKCVec_PhantomRouteHintsZ phantom_route_hints_constr;
53023 phantom_route_hints_constr.datalen = phantom_route_hints->arr_len;
53024 if (phantom_route_hints_constr.datalen > 0)
53025 phantom_route_hints_constr.data = MALLOC(phantom_route_hints_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
53027 phantom_route_hints_constr.data = NULL;
53028 uint64_t* phantom_route_hints_vals = phantom_route_hints->elems;
53029 for (size_t t = 0; t < phantom_route_hints_constr.datalen; t++) {
53030 uint64_t phantom_route_hints_conv_19 = phantom_route_hints_vals[t];
53031 LDKPhantomRouteHints phantom_route_hints_conv_19_conv;
53032 phantom_route_hints_conv_19_conv.inner = untag_ptr(phantom_route_hints_conv_19);
53033 phantom_route_hints_conv_19_conv.is_owned = ptr_is_owned(phantom_route_hints_conv_19);
53034 CHECK_INNER_FIELD_ACCESS_OR_NULL(phantom_route_hints_conv_19_conv);
53035 phantom_route_hints_conv_19_conv = PhantomRouteHints_clone(&phantom_route_hints_conv_19_conv);
53036 phantom_route_hints_constr.data[t] = phantom_route_hints_conv_19_conv;
53038 FREE(phantom_route_hints);
53039 void* entropy_source_ptr = untag_ptr(entropy_source);
53040 CHECK_ACCESS(entropy_source_ptr);
53041 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
53042 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
53043 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53044 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
53046 void* node_signer_ptr = untag_ptr(node_signer);
53047 CHECK_ACCESS(node_signer_ptr);
53048 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53049 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53050 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53051 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53053 void* logger_ptr = untag_ptr(logger);
53054 CHECK_ACCESS(logger_ptr);
53055 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53056 if (logger_conv.free == LDKLogger_JCalls_free) {
53057 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53058 LDKLogger_JCalls_cloned(&logger_conv);
53060 LDKCurrency network_conv = LDKCurrency_from_js(network);
53061 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53062 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53063 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53064 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53065 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53066 *ret_conv = create_phantom_invoice_with_description_hash(amt_msat_conv, payment_hash_ref, invoice_expiry_delta_secs, description_hash_conv, phantom_route_hints_constr, entropy_source_conv, node_signer_conv, logger_conv, network_conv, min_final_cltv_expiry_delta_conv, duration_since_epoch);
53067 return tag_ptr(ret_conv, true);
53070 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 node_signer, 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, uint64_t min_final_cltv_expiry_delta) {
53071 LDKChannelManager channelmanager_conv;
53072 channelmanager_conv.inner = untag_ptr(channelmanager);
53073 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
53074 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
53075 channelmanager_conv.is_owned = false;
53076 void* node_signer_ptr = untag_ptr(node_signer);
53077 CHECK_ACCESS(node_signer_ptr);
53078 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53079 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53080 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53081 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53083 void* logger_ptr = untag_ptr(logger);
53084 CHECK_ACCESS(logger_ptr);
53085 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53086 if (logger_conv.free == LDKLogger_JCalls_free) {
53087 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53088 LDKLogger_JCalls_cloned(&logger_conv);
53090 LDKCurrency network_conv = LDKCurrency_from_js(network);
53091 void* amt_msat_ptr = untag_ptr(amt_msat);
53092 CHECK_ACCESS(amt_msat_ptr);
53093 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53094 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53095 LDKSha256 description_hash_conv;
53096 description_hash_conv.inner = untag_ptr(description_hash);
53097 description_hash_conv.is_owned = ptr_is_owned(description_hash);
53098 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
53099 description_hash_conv = Sha256_clone(&description_hash_conv);
53100 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53101 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53102 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53103 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53104 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53105 *ret_conv = create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(&channelmanager_conv, node_signer_conv, logger_conv, network_conv, amt_msat_conv, description_hash_conv, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta_conv);
53106 return tag_ptr(ret_conv, true);
53109 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 node_signer, uint64_t logger, uint32_t network, uint64_t amt_msat, jstring description, int64_t duration_since_epoch, int32_t invoice_expiry_delta_secs, uint64_t min_final_cltv_expiry_delta) {
53110 LDKChannelManager channelmanager_conv;
53111 channelmanager_conv.inner = untag_ptr(channelmanager);
53112 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
53113 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
53114 channelmanager_conv.is_owned = false;
53115 void* node_signer_ptr = untag_ptr(node_signer);
53116 CHECK_ACCESS(node_signer_ptr);
53117 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53118 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53119 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53120 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53122 void* logger_ptr = untag_ptr(logger);
53123 CHECK_ACCESS(logger_ptr);
53124 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53125 if (logger_conv.free == LDKLogger_JCalls_free) {
53126 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53127 LDKLogger_JCalls_cloned(&logger_conv);
53129 LDKCurrency network_conv = LDKCurrency_from_js(network);
53130 void* amt_msat_ptr = untag_ptr(amt_msat);
53131 CHECK_ACCESS(amt_msat_ptr);
53132 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53133 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53134 LDKStr description_conv = str_ref_to_owned_c(description);
53135 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53136 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53137 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53138 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53139 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53140 *ret_conv = create_invoice_from_channelmanager_and_duration_since_epoch(&channelmanager_conv, node_signer_conv, logger_conv, network_conv, amt_msat_conv, description_conv, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta_conv);
53141 return tag_ptr(ret_conv, true);
53144 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 node_signer, 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, uint64_t min_final_cltv_expiry_delta) {
53145 LDKChannelManager channelmanager_conv;
53146 channelmanager_conv.inner = untag_ptr(channelmanager);
53147 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
53148 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
53149 channelmanager_conv.is_owned = false;
53150 void* node_signer_ptr = untag_ptr(node_signer);
53151 CHECK_ACCESS(node_signer_ptr);
53152 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53153 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53154 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53155 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53157 void* logger_ptr = untag_ptr(logger);
53158 CHECK_ACCESS(logger_ptr);
53159 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53160 if (logger_conv.free == LDKLogger_JCalls_free) {
53161 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53162 LDKLogger_JCalls_cloned(&logger_conv);
53164 LDKCurrency network_conv = LDKCurrency_from_js(network);
53165 void* amt_msat_ptr = untag_ptr(amt_msat);
53166 CHECK_ACCESS(amt_msat_ptr);
53167 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53168 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53169 LDKStr description_conv = str_ref_to_owned_c(description);
53170 LDKThirtyTwoBytes payment_hash_ref;
53171 CHECK(payment_hash->arr_len == 32);
53172 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
53173 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53174 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53175 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53176 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53177 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53178 *ret_conv = create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(&channelmanager_conv, node_signer_conv, logger_conv, network_conv, amt_msat_conv, description_conv, duration_since_epoch, invoice_expiry_delta_secs, payment_hash_ref, min_final_cltv_expiry_delta_conv);
53179 return tag_ptr(ret_conv, true);
53182 uint64_t __attribute__((export_name("TS_SiPrefix_from_str"))) TS_SiPrefix_from_str(jstring s) {
53183 LDKStr s_conv = str_ref_to_owned_c(s);
53184 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
53185 *ret_conv = SiPrefix_from_str(s_conv);
53186 return tag_ptr(ret_conv, true);
53189 uint64_t __attribute__((export_name("TS_Invoice_from_str"))) TS_Invoice_from_str(jstring s) {
53190 LDKStr s_conv = str_ref_to_owned_c(s);
53191 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
53192 *ret_conv = Invoice_from_str(s_conv);
53193 return tag_ptr(ret_conv, true);
53196 uint64_t __attribute__((export_name("TS_SignedRawInvoice_from_str"))) TS_SignedRawInvoice_from_str(jstring s) {
53197 LDKStr s_conv = str_ref_to_owned_c(s);
53198 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
53199 *ret_conv = SignedRawInvoice_from_str(s_conv);
53200 return tag_ptr(ret_conv, true);
53203 jstring __attribute__((export_name("TS_ParseError_to_str"))) TS_ParseError_to_str(uint64_t o) {
53204 LDKParseError* o_conv = (LDKParseError*)untag_ptr(o);
53205 LDKStr ret_str = ParseError_to_str(o_conv);
53206 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53211 jstring __attribute__((export_name("TS_ParseOrSemanticError_to_str"))) TS_ParseOrSemanticError_to_str(uint64_t o) {
53212 LDKParseOrSemanticError* o_conv = (LDKParseOrSemanticError*)untag_ptr(o);
53213 LDKStr ret_str = ParseOrSemanticError_to_str(o_conv);
53214 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53219 jstring __attribute__((export_name("TS_Invoice_to_str"))) TS_Invoice_to_str(uint64_t o) {
53221 o_conv.inner = untag_ptr(o);
53222 o_conv.is_owned = ptr_is_owned(o);
53223 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
53224 o_conv.is_owned = false;
53225 LDKStr ret_str = Invoice_to_str(&o_conv);
53226 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53231 jstring __attribute__((export_name("TS_SignedRawInvoice_to_str"))) TS_SignedRawInvoice_to_str(uint64_t o) {
53232 LDKSignedRawInvoice o_conv;
53233 o_conv.inner = untag_ptr(o);
53234 o_conv.is_owned = ptr_is_owned(o);
53235 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
53236 o_conv.is_owned = false;
53237 LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
53238 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53243 jstring __attribute__((export_name("TS_Currency_to_str"))) TS_Currency_to_str(uint64_t o) {
53244 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
53245 LDKStr ret_str = Currency_to_str(o_conv);
53246 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53251 jstring __attribute__((export_name("TS_SiPrefix_to_str"))) TS_SiPrefix_to_str(uint64_t o) {
53252 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
53253 LDKStr ret_str = SiPrefix_to_str(o_conv);
53254 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);