1 #define LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ LDKCVec_TransactionOutputsZ
2 #define CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free CVec_TransactionOutputsZ_free
7 // These should be provided...somehow...
8 void *memset(void *s, int c, size_t n);
9 void *memcpy(void *dest, const void *src, size_t n);
10 int memcmp(const void *s1, const void *s2, size_t n);
12 extern void __attribute__((noreturn)) abort(void);
13 static inline void assert(bool expression) {
14 if (!expression) { abort(); }
17 uint32_t __attribute__((export_name("test_bigint_pass_deadbeef0badf00d"))) test_bigint_pass_deadbeef0badf00d(uint64_t val) {
18 return val == 0xdeadbeef0badf00dULL;
22 void *malloc(size_t size);
25 #define MALLOC(a, _) malloc(a)
26 #define do_MALLOC(a, _b, _c) malloc(a)
27 #define FREE(p) if ((unsigned long)(p) > 4096) { free(p); }
28 #define DO_ASSERT(a) (void)(a)
30 #define CHECK_ACCESS(p)
31 #define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
33 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
34 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
35 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
36 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
38 _Static_assert(sizeof(void*) == 4, "Pointers mut be 32 bits");
40 #define DECL_ARR_TYPE(ty, name) \
41 struct name##array { \
42 uint64_t arr_len; /* uint32_t would suffice but we want to align uint64_ts as well */ \
45 typedef struct name##array * name##Array; \
46 static inline name##Array init_##name##Array(size_t arr_len, int lineno) { \
47 name##Array arr = (name##Array)do_MALLOC(arr_len * sizeof(ty) + sizeof(uint64_t), #name" array init", lineno); \
48 arr->arr_len = arr_len; \
52 DECL_ARR_TYPE(int64_t, int64_t);
53 DECL_ARR_TYPE(uint64_t, uint64_t);
54 DECL_ARR_TYPE(int8_t, int8_t);
55 DECL_ARR_TYPE(int16_t, int16_t);
56 DECL_ARR_TYPE(uint32_t, uint32_t);
57 DECL_ARR_TYPE(void*, ptr);
58 DECL_ARR_TYPE(char, char);
59 typedef charArray jstring;
61 static inline jstring str_ref_to_ts(const char* chars, size_t len) {
62 charArray arr = init_charArray(len, __LINE__);
63 memcpy(arr->elems, chars, len);
66 static inline LDKStr str_ref_to_owned_c(const jstring str) {
67 char* newchars = MALLOC(str->arr_len + 1, "String chars");
68 memcpy(newchars, str->elems, str->arr_len);
69 newchars[str->arr_len] = 0;
73 .chars_is_owned = true
78 typedef bool jboolean;
80 uint32_t __attribute__((export_name("TS_malloc"))) TS_malloc(uint32_t size) {
81 return (uint32_t)MALLOC(size, "JS-Called malloc");
83 void __attribute__((export_name("TS_free"))) TS_free(uint32_t ptr) {
87 jstring __attribute__((export_name("TS_get_ldk_c_bindings_version"))) TS_get_ldk_c_bindings_version() {
88 const char *res = check_get_ldk_bindings_version();
89 if (res == NULL) return NULL;
90 return str_ref_to_ts(res, strlen(res));
92 jstring __attribute__((export_name("TS_get_ldk_version"))) get_ldk_version() {
93 const char *res = check_get_ldk_version();
94 if (res == NULL) return NULL;
95 return str_ref_to_ts(res, strlen(res));
98 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
100 static inline void* untag_ptr(uint64_t ptr) {
101 if (ptr < 4096) return (void*)ptr;
102 if (sizeof(void*) == 4) {
103 // For 32-bit systems, store pointers as 64-bit ints and use the 31st bit
104 return (void*)(uintptr_t)ptr;
106 // For 64-bit systems, assume the top byte is used for tagging, then
107 // use bit 9 ^ bit 10.
108 uint64_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
109 uintptr_t p = (ptr & ~(1ULL << 55)) | (tenth_bit << 55);
110 #ifdef LDK_DEBUG_BUILD
111 // On debug builds we also use the 11th bit as a debug flag
112 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
113 CHECK(tenth_bit != eleventh_bit);
119 static inline bool ptr_is_owned(uint64_t ptr) {
120 if(ptr < 4096) return true;
121 if (sizeof(void*) == 4) {
122 return ptr & (1ULL << 32);
124 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
125 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
126 #ifdef LDK_DEBUG_BUILD
127 // On debug builds we also use the 11th bit as a debug flag
128 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
129 CHECK(tenth_bit != eleventh_bit);
131 return (ninth_bit ^ tenth_bit) ? true : false;
134 static inline uint64_t tag_ptr(const void* ptr, bool is_owned) {
135 if ((uintptr_t)ptr < 4096) return (uint64_t)ptr;
136 if (sizeof(void*) == 4) {
137 return (((uint64_t)ptr) | ((is_owned ? 1ULL : 0) << 32));
139 CHECK(sizeof(uintptr_t) == 8);
140 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
141 uintptr_t t = (((uintptr_t)ptr) | (((is_owned ? 1ULL : 0ULL) ^ tenth_bit) << 55));
142 #ifdef LDK_DEBUG_BUILD
143 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
144 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
145 CHECK(ninth_bit == tenth_bit);
146 CHECK(ninth_bit == eleventh_bit);
149 CHECK(ptr_is_owned(t) == is_owned);
150 CHECK(untag_ptr(t) == ptr);
155 static inline LDKCOption_NoneZ LDKCOption_NoneZ_from_js(int32_t ord) {
157 case 0: return LDKCOption_NoneZ_Some;
158 case 1: return LDKCOption_NoneZ_None;
162 static inline int32_t LDKCOption_NoneZ_to_js(LDKCOption_NoneZ val) {
164 case LDKCOption_NoneZ_Some: return 0;
165 case LDKCOption_NoneZ_None: return 1;
169 static inline LDKChannelMonitorUpdateStatus LDKChannelMonitorUpdateStatus_from_js(int32_t ord) {
171 case 0: return LDKChannelMonitorUpdateStatus_Completed;
172 case 1: return LDKChannelMonitorUpdateStatus_InProgress;
173 case 2: return LDKChannelMonitorUpdateStatus_PermanentFailure;
177 static inline int32_t LDKChannelMonitorUpdateStatus_to_js(LDKChannelMonitorUpdateStatus val) {
179 case LDKChannelMonitorUpdateStatus_Completed: return 0;
180 case LDKChannelMonitorUpdateStatus_InProgress: return 1;
181 case LDKChannelMonitorUpdateStatus_PermanentFailure: return 2;
185 static inline LDKConfirmationTarget LDKConfirmationTarget_from_js(int32_t ord) {
187 case 0: return LDKConfirmationTarget_Background;
188 case 1: return LDKConfirmationTarget_Normal;
189 case 2: return LDKConfirmationTarget_HighPriority;
193 static inline int32_t LDKConfirmationTarget_to_js(LDKConfirmationTarget val) {
195 case LDKConfirmationTarget_Background: return 0;
196 case LDKConfirmationTarget_Normal: return 1;
197 case LDKConfirmationTarget_HighPriority: return 2;
201 static inline LDKCreationError LDKCreationError_from_js(int32_t ord) {
203 case 0: return LDKCreationError_DescriptionTooLong;
204 case 1: return LDKCreationError_RouteTooLong;
205 case 2: return LDKCreationError_TimestampOutOfBounds;
206 case 3: return LDKCreationError_InvalidAmount;
207 case 4: return LDKCreationError_MissingRouteHints;
208 case 5: return LDKCreationError_MinFinalCltvExpiryDeltaTooShort;
212 static inline int32_t LDKCreationError_to_js(LDKCreationError val) {
214 case LDKCreationError_DescriptionTooLong: return 0;
215 case LDKCreationError_RouteTooLong: return 1;
216 case LDKCreationError_TimestampOutOfBounds: return 2;
217 case LDKCreationError_InvalidAmount: return 3;
218 case LDKCreationError_MissingRouteHints: return 4;
219 case LDKCreationError_MinFinalCltvExpiryDeltaTooShort: return 5;
223 static inline LDKCurrency LDKCurrency_from_js(int32_t ord) {
225 case 0: return LDKCurrency_Bitcoin;
226 case 1: return LDKCurrency_BitcoinTestnet;
227 case 2: return LDKCurrency_Regtest;
228 case 3: return LDKCurrency_Simnet;
229 case 4: return LDKCurrency_Signet;
233 static inline int32_t LDKCurrency_to_js(LDKCurrency val) {
235 case LDKCurrency_Bitcoin: return 0;
236 case LDKCurrency_BitcoinTestnet: return 1;
237 case LDKCurrency_Regtest: return 2;
238 case LDKCurrency_Simnet: return 3;
239 case LDKCurrency_Signet: return 4;
243 static inline LDKFailureCode LDKFailureCode_from_js(int32_t ord) {
245 case 0: return LDKFailureCode_TemporaryNodeFailure;
246 case 1: return LDKFailureCode_RequiredNodeFeatureMissing;
247 case 2: return LDKFailureCode_IncorrectOrUnknownPaymentDetails;
251 static inline int32_t LDKFailureCode_to_js(LDKFailureCode val) {
253 case LDKFailureCode_TemporaryNodeFailure: return 0;
254 case LDKFailureCode_RequiredNodeFeatureMissing: return 1;
255 case LDKFailureCode_IncorrectOrUnknownPaymentDetails: return 2;
259 static inline LDKHTLCClaim LDKHTLCClaim_from_js(int32_t ord) {
261 case 0: return LDKHTLCClaim_OfferedTimeout;
262 case 1: return LDKHTLCClaim_OfferedPreimage;
263 case 2: return LDKHTLCClaim_AcceptedTimeout;
264 case 3: return LDKHTLCClaim_AcceptedPreimage;
265 case 4: return LDKHTLCClaim_Revocation;
269 static inline int32_t LDKHTLCClaim_to_js(LDKHTLCClaim val) {
271 case LDKHTLCClaim_OfferedTimeout: return 0;
272 case LDKHTLCClaim_OfferedPreimage: return 1;
273 case LDKHTLCClaim_AcceptedTimeout: return 2;
274 case LDKHTLCClaim_AcceptedPreimage: return 3;
275 case LDKHTLCClaim_Revocation: return 4;
279 static inline LDKIOError LDKIOError_from_js(int32_t ord) {
281 case 0: return LDKIOError_NotFound;
282 case 1: return LDKIOError_PermissionDenied;
283 case 2: return LDKIOError_ConnectionRefused;
284 case 3: return LDKIOError_ConnectionReset;
285 case 4: return LDKIOError_ConnectionAborted;
286 case 5: return LDKIOError_NotConnected;
287 case 6: return LDKIOError_AddrInUse;
288 case 7: return LDKIOError_AddrNotAvailable;
289 case 8: return LDKIOError_BrokenPipe;
290 case 9: return LDKIOError_AlreadyExists;
291 case 10: return LDKIOError_WouldBlock;
292 case 11: return LDKIOError_InvalidInput;
293 case 12: return LDKIOError_InvalidData;
294 case 13: return LDKIOError_TimedOut;
295 case 14: return LDKIOError_WriteZero;
296 case 15: return LDKIOError_Interrupted;
297 case 16: return LDKIOError_Other;
298 case 17: return LDKIOError_UnexpectedEof;
302 static inline int32_t LDKIOError_to_js(LDKIOError val) {
304 case LDKIOError_NotFound: return 0;
305 case LDKIOError_PermissionDenied: return 1;
306 case LDKIOError_ConnectionRefused: return 2;
307 case LDKIOError_ConnectionReset: return 3;
308 case LDKIOError_ConnectionAborted: return 4;
309 case LDKIOError_NotConnected: return 5;
310 case LDKIOError_AddrInUse: return 6;
311 case LDKIOError_AddrNotAvailable: return 7;
312 case LDKIOError_BrokenPipe: return 8;
313 case LDKIOError_AlreadyExists: return 9;
314 case LDKIOError_WouldBlock: return 10;
315 case LDKIOError_InvalidInput: return 11;
316 case LDKIOError_InvalidData: return 12;
317 case LDKIOError_TimedOut: return 13;
318 case LDKIOError_WriteZero: return 14;
319 case LDKIOError_Interrupted: return 15;
320 case LDKIOError_Other: return 16;
321 case LDKIOError_UnexpectedEof: return 17;
325 static inline LDKLevel LDKLevel_from_js(int32_t ord) {
327 case 0: return LDKLevel_Gossip;
328 case 1: return LDKLevel_Trace;
329 case 2: return LDKLevel_Debug;
330 case 3: return LDKLevel_Info;
331 case 4: return LDKLevel_Warn;
332 case 5: return LDKLevel_Error;
336 static inline int32_t LDKLevel_to_js(LDKLevel val) {
338 case LDKLevel_Gossip: return 0;
339 case LDKLevel_Trace: return 1;
340 case LDKLevel_Debug: return 2;
341 case LDKLevel_Info: return 3;
342 case LDKLevel_Warn: return 4;
343 case LDKLevel_Error: return 5;
347 static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
349 case 0: return LDKNetwork_Bitcoin;
350 case 1: return LDKNetwork_Testnet;
351 case 2: return LDKNetwork_Regtest;
352 case 3: return LDKNetwork_Signet;
356 static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
358 case LDKNetwork_Bitcoin: return 0;
359 case LDKNetwork_Testnet: return 1;
360 case LDKNetwork_Regtest: return 2;
361 case LDKNetwork_Signet: return 3;
365 static inline LDKPaymentFailureReason LDKPaymentFailureReason_from_js(int32_t ord) {
367 case 0: return LDKPaymentFailureReason_RecipientRejected;
368 case 1: return LDKPaymentFailureReason_UserAbandoned;
369 case 2: return LDKPaymentFailureReason_RetriesExhausted;
370 case 3: return LDKPaymentFailureReason_PaymentExpired;
371 case 4: return LDKPaymentFailureReason_RouteNotFound;
372 case 5: return LDKPaymentFailureReason_UnexpectedError;
376 static inline int32_t LDKPaymentFailureReason_to_js(LDKPaymentFailureReason val) {
378 case LDKPaymentFailureReason_RecipientRejected: return 0;
379 case LDKPaymentFailureReason_UserAbandoned: return 1;
380 case LDKPaymentFailureReason_RetriesExhausted: return 2;
381 case LDKPaymentFailureReason_PaymentExpired: return 3;
382 case LDKPaymentFailureReason_RouteNotFound: return 4;
383 case LDKPaymentFailureReason_UnexpectedError: return 5;
387 static inline LDKRecipient LDKRecipient_from_js(int32_t ord) {
389 case 0: return LDKRecipient_Node;
390 case 1: return LDKRecipient_PhantomNode;
394 static inline int32_t LDKRecipient_to_js(LDKRecipient val) {
396 case LDKRecipient_Node: return 0;
397 case LDKRecipient_PhantomNode: return 1;
401 static inline LDKRetryableSendFailure LDKRetryableSendFailure_from_js(int32_t ord) {
403 case 0: return LDKRetryableSendFailure_PaymentExpired;
404 case 1: return LDKRetryableSendFailure_RouteNotFound;
405 case 2: return LDKRetryableSendFailure_DuplicatePayment;
409 static inline int32_t LDKRetryableSendFailure_to_js(LDKRetryableSendFailure val) {
411 case LDKRetryableSendFailure_PaymentExpired: return 0;
412 case LDKRetryableSendFailure_RouteNotFound: return 1;
413 case LDKRetryableSendFailure_DuplicatePayment: return 2;
417 static inline LDKSecp256k1Error LDKSecp256k1Error_from_js(int32_t ord) {
419 case 0: return LDKSecp256k1Error_IncorrectSignature;
420 case 1: return LDKSecp256k1Error_InvalidMessage;
421 case 2: return LDKSecp256k1Error_InvalidPublicKey;
422 case 3: return LDKSecp256k1Error_InvalidSignature;
423 case 4: return LDKSecp256k1Error_InvalidSecretKey;
424 case 5: return LDKSecp256k1Error_InvalidSharedSecret;
425 case 6: return LDKSecp256k1Error_InvalidRecoveryId;
426 case 7: return LDKSecp256k1Error_InvalidTweak;
427 case 8: return LDKSecp256k1Error_NotEnoughMemory;
428 case 9: return LDKSecp256k1Error_InvalidPublicKeySum;
429 case 10: return LDKSecp256k1Error_InvalidParityValue;
433 static inline int32_t LDKSecp256k1Error_to_js(LDKSecp256k1Error val) {
435 case LDKSecp256k1Error_IncorrectSignature: return 0;
436 case LDKSecp256k1Error_InvalidMessage: return 1;
437 case LDKSecp256k1Error_InvalidPublicKey: return 2;
438 case LDKSecp256k1Error_InvalidSignature: return 3;
439 case LDKSecp256k1Error_InvalidSecretKey: return 4;
440 case LDKSecp256k1Error_InvalidSharedSecret: return 5;
441 case LDKSecp256k1Error_InvalidRecoveryId: return 6;
442 case LDKSecp256k1Error_InvalidTweak: return 7;
443 case LDKSecp256k1Error_NotEnoughMemory: return 8;
444 case LDKSecp256k1Error_InvalidPublicKeySum: return 9;
445 case LDKSecp256k1Error_InvalidParityValue: return 10;
449 static inline LDKSemanticError LDKSemanticError_from_js(int32_t ord) {
451 case 0: return LDKSemanticError_NoPaymentHash;
452 case 1: return LDKSemanticError_MultiplePaymentHashes;
453 case 2: return LDKSemanticError_NoDescription;
454 case 3: return LDKSemanticError_MultipleDescriptions;
455 case 4: return LDKSemanticError_NoPaymentSecret;
456 case 5: return LDKSemanticError_MultiplePaymentSecrets;
457 case 6: return LDKSemanticError_InvalidFeatures;
458 case 7: return LDKSemanticError_InvalidRecoveryId;
459 case 8: return LDKSemanticError_InvalidSignature;
460 case 9: return LDKSemanticError_ImpreciseAmount;
464 static inline int32_t LDKSemanticError_to_js(LDKSemanticError val) {
466 case LDKSemanticError_NoPaymentHash: return 0;
467 case LDKSemanticError_MultiplePaymentHashes: return 1;
468 case LDKSemanticError_NoDescription: return 2;
469 case LDKSemanticError_MultipleDescriptions: return 3;
470 case LDKSemanticError_NoPaymentSecret: return 4;
471 case LDKSemanticError_MultiplePaymentSecrets: return 5;
472 case LDKSemanticError_InvalidFeatures: return 6;
473 case LDKSemanticError_InvalidRecoveryId: return 7;
474 case LDKSemanticError_InvalidSignature: return 8;
475 case LDKSemanticError_ImpreciseAmount: return 9;
479 static inline LDKSiPrefix LDKSiPrefix_from_js(int32_t ord) {
481 case 0: return LDKSiPrefix_Milli;
482 case 1: return LDKSiPrefix_Micro;
483 case 2: return LDKSiPrefix_Nano;
484 case 3: return LDKSiPrefix_Pico;
488 static inline int32_t LDKSiPrefix_to_js(LDKSiPrefix val) {
490 case LDKSiPrefix_Milli: return 0;
491 case LDKSiPrefix_Micro: return 1;
492 case LDKSiPrefix_Nano: return 2;
493 case LDKSiPrefix_Pico: return 3;
497 static inline LDKUtxoLookupError LDKUtxoLookupError_from_js(int32_t ord) {
499 case 0: return LDKUtxoLookupError_UnknownChain;
500 case 1: return LDKUtxoLookupError_UnknownTx;
504 static inline int32_t LDKUtxoLookupError_to_js(LDKUtxoLookupError val) {
506 case LDKUtxoLookupError_UnknownChain: return 0;
507 case LDKUtxoLookupError_UnknownTx: return 1;
511 struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing) {
512 LDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };
515 int8_tArray __attribute__((export_name("TS_BigEndianScalar_get_bytes"))) TS_BigEndianScalar_get_bytes(uint64_t thing) {
516 LDKBigEndianScalar* thing_conv = (LDKBigEndianScalar*)untag_ptr(thing);
517 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
518 memcpy(ret_arr->elems, BigEndianScalar_get_bytes(thing_conv).data, 32);
522 static void BigEndianScalar_free (struct LDKBigEndianScalar thing) {}
523 void __attribute__((export_name("TS_BigEndianScalar_free"))) TS_BigEndianScalar_free(uint64_t thing) {
524 if (!ptr_is_owned(thing)) return;
525 void* thing_ptr = untag_ptr(thing);
526 CHECK_ACCESS(thing_ptr);
527 LDKBigEndianScalar thing_conv = *(LDKBigEndianScalar*)(thing_ptr);
528 FREE(untag_ptr(thing));
529 BigEndianScalar_free(thing_conv);
532 uint32_t __attribute__((export_name("TS_LDKBech32Error_ty_from_ptr"))) TS_LDKBech32Error_ty_from_ptr(uint64_t ptr) {
533 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
535 case LDKBech32Error_MissingSeparator: return 0;
536 case LDKBech32Error_InvalidChecksum: return 1;
537 case LDKBech32Error_InvalidLength: return 2;
538 case LDKBech32Error_InvalidChar: return 3;
539 case LDKBech32Error_InvalidData: return 4;
540 case LDKBech32Error_InvalidPadding: return 5;
541 case LDKBech32Error_MixedCase: return 6;
545 int32_t __attribute__((export_name("TS_LDKBech32Error_InvalidChar_get_invalid_char"))) TS_LDKBech32Error_InvalidChar_get_invalid_char(uint64_t ptr) {
546 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
547 assert(obj->tag == LDKBech32Error_InvalidChar);
548 int32_t invalid_char_conv = obj->invalid_char;
549 return invalid_char_conv;
551 int8_t __attribute__((export_name("TS_LDKBech32Error_InvalidData_get_invalid_data"))) TS_LDKBech32Error_InvalidData_get_invalid_data(uint64_t ptr) {
552 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
553 assert(obj->tag == LDKBech32Error_InvalidData);
554 int8_t invalid_data_conv = obj->invalid_data;
555 return invalid_data_conv;
557 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
558 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
559 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
562 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) {
563 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
564 LDKCVec_u8Z ret_var = TxOut_get_script_pubkey(thing_conv);
565 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
566 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
567 CVec_u8Z_free(ret_var);
571 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) {
572 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
573 int64_t ret_conv = TxOut_get_value(thing_conv);
577 uint32_t __attribute__((export_name("TS_LDKCOption_DurationZ_ty_from_ptr"))) TS_LDKCOption_DurationZ_ty_from_ptr(uint64_t ptr) {
578 LDKCOption_DurationZ *obj = (LDKCOption_DurationZ*)untag_ptr(ptr);
580 case LDKCOption_DurationZ_Some: return 0;
581 case LDKCOption_DurationZ_None: return 1;
585 int64_t __attribute__((export_name("TS_LDKCOption_DurationZ_Some_get_some"))) TS_LDKCOption_DurationZ_Some_get_some(uint64_t ptr) {
586 LDKCOption_DurationZ *obj = (LDKCOption_DurationZ*)untag_ptr(ptr);
587 assert(obj->tag == LDKCOption_DurationZ_Some);
588 int64_t some_conv = obj->some;
591 static inline LDKCVec_BlindedPathZ CVec_BlindedPathZ_clone(const LDKCVec_BlindedPathZ *orig) {
592 LDKCVec_BlindedPathZ ret = { .data = MALLOC(sizeof(LDKBlindedPath) * orig->datalen, "LDKCVec_BlindedPathZ clone bytes"), .datalen = orig->datalen };
593 for (size_t i = 0; i < ret.datalen; i++) {
594 ret.data[i] = BlindedPath_clone(&orig->data[i]);
598 uint32_t __attribute__((export_name("TS_LDKCOption_u64Z_ty_from_ptr"))) TS_LDKCOption_u64Z_ty_from_ptr(uint64_t ptr) {
599 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
601 case LDKCOption_u64Z_Some: return 0;
602 case LDKCOption_u64Z_None: return 1;
606 int64_t __attribute__((export_name("TS_LDKCOption_u64Z_Some_get_some"))) TS_LDKCOption_u64Z_Some_get_some(uint64_t ptr) {
607 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
608 assert(obj->tag == LDKCOption_u64Z_Some);
609 int64_t some_conv = obj->some;
612 uint32_t __attribute__((export_name("TS_LDKAPIError_ty_from_ptr"))) TS_LDKAPIError_ty_from_ptr(uint64_t ptr) {
613 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
615 case LDKAPIError_APIMisuseError: return 0;
616 case LDKAPIError_FeeRateTooHigh: return 1;
617 case LDKAPIError_InvalidRoute: return 2;
618 case LDKAPIError_ChannelUnavailable: return 3;
619 case LDKAPIError_MonitorUpdateInProgress: return 4;
620 case LDKAPIError_IncompatibleShutdownScript: return 5;
624 jstring __attribute__((export_name("TS_LDKAPIError_APIMisuseError_get_err"))) TS_LDKAPIError_APIMisuseError_get_err(uint64_t ptr) {
625 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
626 assert(obj->tag == LDKAPIError_APIMisuseError);
627 LDKStr err_str = obj->api_misuse_error.err;
628 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
631 jstring __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_err"))) TS_LDKAPIError_FeeRateTooHigh_get_err(uint64_t ptr) {
632 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
633 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
634 LDKStr err_str = obj->fee_rate_too_high.err;
635 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
638 int32_t __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_feerate"))) TS_LDKAPIError_FeeRateTooHigh_get_feerate(uint64_t ptr) {
639 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
640 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
641 int32_t feerate_conv = obj->fee_rate_too_high.feerate;
644 jstring __attribute__((export_name("TS_LDKAPIError_InvalidRoute_get_err"))) TS_LDKAPIError_InvalidRoute_get_err(uint64_t ptr) {
645 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
646 assert(obj->tag == LDKAPIError_InvalidRoute);
647 LDKStr err_str = obj->invalid_route.err;
648 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
651 jstring __attribute__((export_name("TS_LDKAPIError_ChannelUnavailable_get_err"))) TS_LDKAPIError_ChannelUnavailable_get_err(uint64_t ptr) {
652 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
653 assert(obj->tag == LDKAPIError_ChannelUnavailable);
654 LDKStr err_str = obj->channel_unavailable.err;
655 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
658 uint64_t __attribute__((export_name("TS_LDKAPIError_IncompatibleShutdownScript_get_script"))) TS_LDKAPIError_IncompatibleShutdownScript_get_script(uint64_t ptr) {
659 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
660 assert(obj->tag == LDKAPIError_IncompatibleShutdownScript);
661 LDKShutdownScript script_var = obj->incompatible_shutdown_script.script;
662 uint64_t script_ref = 0;
663 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
664 script_ref = tag_ptr(script_var.inner, false);
667 static inline void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
668 CHECK(owner->result_ok);
669 return *owner->contents.result;
671 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_ok"))) TS_CResult_NoneAPIErrorZ_get_ok(uint64_t owner) {
672 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
673 CResult_NoneAPIErrorZ_get_ok(owner_conv);
676 static inline struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
677 CHECK(!owner->result_ok);
678 return APIError_clone(&*owner->contents.err);
680 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_err"))) TS_CResult_NoneAPIErrorZ_get_err(uint64_t owner) {
681 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
682 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
683 *ret_copy = CResult_NoneAPIErrorZ_get_err(owner_conv);
684 uint64_t ret_ref = tag_ptr(ret_copy, true);
688 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
689 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
690 for (size_t i = 0; i < ret.datalen; i++) {
691 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
695 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
696 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
697 for (size_t i = 0; i < ret.datalen; i++) {
698 ret.data[i] = APIError_clone(&orig->data[i]);
702 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_u8ZZ_ty_from_ptr"))) TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(uint64_t ptr) {
703 LDKCOption_CVec_u8ZZ *obj = (LDKCOption_CVec_u8ZZ*)untag_ptr(ptr);
705 case LDKCOption_CVec_u8ZZ_Some: return 0;
706 case LDKCOption_CVec_u8ZZ_None: return 1;
710 int8_tArray __attribute__((export_name("TS_LDKCOption_CVec_u8ZZ_Some_get_some"))) TS_LDKCOption_CVec_u8ZZ_Some_get_some(uint64_t ptr) {
711 LDKCOption_CVec_u8ZZ *obj = (LDKCOption_CVec_u8ZZ*)untag_ptr(ptr);
712 assert(obj->tag == LDKCOption_CVec_u8ZZ_Some);
713 LDKCVec_u8Z some_var = obj->some;
714 int8_tArray some_arr = init_int8_tArray(some_var.datalen, __LINE__);
715 memcpy(some_arr->elems, some_var.data, some_var.datalen);
718 uint32_t __attribute__((export_name("TS_LDKDecodeError_ty_from_ptr"))) TS_LDKDecodeError_ty_from_ptr(uint64_t ptr) {
719 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
721 case LDKDecodeError_UnknownVersion: return 0;
722 case LDKDecodeError_UnknownRequiredFeature: return 1;
723 case LDKDecodeError_InvalidValue: return 2;
724 case LDKDecodeError_ShortRead: return 3;
725 case LDKDecodeError_BadLengthDescriptor: return 4;
726 case LDKDecodeError_Io: return 5;
727 case LDKDecodeError_UnsupportedCompression: return 6;
731 uint32_t __attribute__((export_name("TS_LDKDecodeError_Io_get_io"))) TS_LDKDecodeError_Io_get_io(uint64_t ptr) {
732 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
733 assert(obj->tag == LDKDecodeError_Io);
734 uint32_t io_conv = LDKIOError_to_js(obj->io);
737 static inline struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner){
738 LDKRecipientOnionFields ret = *owner->contents.result;
739 ret.is_owned = false;
742 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(uint64_t owner) {
743 LDKCResult_RecipientOnionFieldsDecodeErrorZ* owner_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(owner);
744 LDKRecipientOnionFields ret_var = CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner_conv);
745 uint64_t ret_ref = 0;
746 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
747 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
751 static inline struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner){
752 CHECK(!owner->result_ok);
753 return DecodeError_clone(&*owner->contents.err);
755 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(uint64_t owner) {
756 LDKCResult_RecipientOnionFieldsDecodeErrorZ* owner_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(owner);
757 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
758 *ret_copy = CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner_conv);
759 uint64_t ret_ref = tag_ptr(ret_copy, true);
763 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_ty_from_ptr"))) TS_LDKCOption_HTLCClaimZ_ty_from_ptr(uint64_t ptr) {
764 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
766 case LDKCOption_HTLCClaimZ_Some: return 0;
767 case LDKCOption_HTLCClaimZ_None: return 1;
771 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_Some_get_some"))) TS_LDKCOption_HTLCClaimZ_Some_get_some(uint64_t ptr) {
772 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
773 assert(obj->tag == LDKCOption_HTLCClaimZ_Some);
774 uint32_t some_conv = LDKHTLCClaim_to_js(obj->some);
777 static inline void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
778 CHECK(owner->result_ok);
779 return *owner->contents.result;
781 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_ok"))) TS_CResult_NoneNoneZ_get_ok(uint64_t owner) {
782 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
783 CResult_NoneNoneZ_get_ok(owner_conv);
786 static inline void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
787 CHECK(!owner->result_ok);
788 return *owner->contents.err;
790 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_err"))) TS_CResult_NoneNoneZ_get_err(uint64_t owner) {
791 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
792 CResult_NoneNoneZ_get_err(owner_conv);
795 static inline struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
796 LDKCounterpartyCommitmentSecrets ret = *owner->contents.result;
797 ret.is_owned = false;
800 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(uint64_t owner) {
801 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
802 LDKCounterpartyCommitmentSecrets ret_var = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner_conv);
803 uint64_t ret_ref = 0;
804 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
805 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
809 static inline struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
810 CHECK(!owner->result_ok);
811 return DecodeError_clone(&*owner->contents.err);
813 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(uint64_t owner) {
814 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
815 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
816 *ret_copy = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner_conv);
817 uint64_t ret_ref = tag_ptr(ret_copy, true);
821 static inline struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
822 LDKTxCreationKeys ret = *owner->contents.result;
823 ret.is_owned = false;
826 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(uint64_t owner) {
827 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
828 LDKTxCreationKeys ret_var = CResult_TxCreationKeysDecodeErrorZ_get_ok(owner_conv);
829 uint64_t ret_ref = 0;
830 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
831 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
835 static inline struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
836 CHECK(!owner->result_ok);
837 return DecodeError_clone(&*owner->contents.err);
839 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_err(uint64_t owner) {
840 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
841 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
842 *ret_copy = CResult_TxCreationKeysDecodeErrorZ_get_err(owner_conv);
843 uint64_t ret_ref = tag_ptr(ret_copy, true);
847 static inline struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
848 LDKChannelPublicKeys ret = *owner->contents.result;
849 ret.is_owned = false;
852 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint64_t owner) {
853 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
854 LDKChannelPublicKeys ret_var = CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner_conv);
855 uint64_t ret_ref = 0;
856 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
857 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
861 static inline struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
862 CHECK(!owner->result_ok);
863 return DecodeError_clone(&*owner->contents.err);
865 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(uint64_t owner) {
866 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
867 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
868 *ret_copy = CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner_conv);
869 uint64_t ret_ref = tag_ptr(ret_copy, true);
873 uint32_t __attribute__((export_name("TS_LDKCOption_u32Z_ty_from_ptr"))) TS_LDKCOption_u32Z_ty_from_ptr(uint64_t ptr) {
874 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
876 case LDKCOption_u32Z_Some: return 0;
877 case LDKCOption_u32Z_None: return 1;
881 int32_t __attribute__((export_name("TS_LDKCOption_u32Z_Some_get_some"))) TS_LDKCOption_u32Z_Some_get_some(uint64_t ptr) {
882 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
883 assert(obj->tag == LDKCOption_u32Z_Some);
884 int32_t some_conv = obj->some;
887 static inline struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
888 LDKHTLCOutputInCommitment ret = *owner->contents.result;
889 ret.is_owned = false;
892 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint64_t owner) {
893 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
894 LDKHTLCOutputInCommitment ret_var = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner_conv);
895 uint64_t ret_ref = 0;
896 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
897 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
901 static inline struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
902 CHECK(!owner->result_ok);
903 return DecodeError_clone(&*owner->contents.err);
905 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(uint64_t owner) {
906 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
907 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
908 *ret_copy = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner_conv);
909 uint64_t ret_ref = tag_ptr(ret_copy, true);
913 static inline struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
914 LDKCounterpartyChannelTransactionParameters ret = *owner->contents.result;
915 ret.is_owned = false;
918 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
919 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
920 LDKCounterpartyChannelTransactionParameters ret_var = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
921 uint64_t ret_ref = 0;
922 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
923 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
927 static inline struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
928 CHECK(!owner->result_ok);
929 return DecodeError_clone(&*owner->contents.err);
931 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
932 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
933 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
934 *ret_copy = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
935 uint64_t ret_ref = tag_ptr(ret_copy, true);
939 static inline struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
940 LDKChannelTransactionParameters ret = *owner->contents.result;
941 ret.is_owned = false;
944 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
945 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
946 LDKChannelTransactionParameters ret_var = CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
947 uint64_t ret_ref = 0;
948 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
949 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
953 static inline struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
954 CHECK(!owner->result_ok);
955 return DecodeError_clone(&*owner->contents.err);
957 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
958 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
959 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
960 *ret_copy = CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
961 uint64_t ret_ref = tag_ptr(ret_copy, true);
965 static inline struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
966 LDKHolderCommitmentTransaction ret = *owner->contents.result;
967 ret.is_owned = false;
970 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
971 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
972 LDKHolderCommitmentTransaction ret_var = CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
973 uint64_t ret_ref = 0;
974 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
975 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
979 static inline struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
980 CHECK(!owner->result_ok);
981 return DecodeError_clone(&*owner->contents.err);
983 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
984 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
985 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
986 *ret_copy = CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
987 uint64_t ret_ref = tag_ptr(ret_copy, true);
991 static inline struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
992 LDKBuiltCommitmentTransaction ret = *owner->contents.result;
993 ret.is_owned = false;
996 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
997 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
998 LDKBuiltCommitmentTransaction ret_var = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
999 uint64_t ret_ref = 0;
1000 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1001 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1005 static inline struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
1006 CHECK(!owner->result_ok);
1007 return DecodeError_clone(&*owner->contents.err);
1009 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
1010 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
1011 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1012 *ret_copy = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
1013 uint64_t ret_ref = tag_ptr(ret_copy, true);
1017 static inline struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
1018 LDKTrustedClosingTransaction ret = *owner->contents.result;
1019 ret.is_owned = false;
1022 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_get_ok(uint64_t owner) {
1023 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
1024 LDKTrustedClosingTransaction ret_var = CResult_TrustedClosingTransactionNoneZ_get_ok(owner_conv);
1025 uint64_t ret_ref = 0;
1026 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1027 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1031 static inline void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
1032 CHECK(!owner->result_ok);
1033 return *owner->contents.err;
1035 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_err"))) TS_CResult_TrustedClosingTransactionNoneZ_get_err(uint64_t owner) {
1036 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
1037 CResult_TrustedClosingTransactionNoneZ_get_err(owner_conv);
1040 static inline struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
1041 LDKCommitmentTransaction ret = *owner->contents.result;
1042 ret.is_owned = false;
1045 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
1046 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
1047 LDKCommitmentTransaction ret_var = CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
1048 uint64_t ret_ref = 0;
1049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1054 static inline struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
1055 CHECK(!owner->result_ok);
1056 return DecodeError_clone(&*owner->contents.err);
1058 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
1059 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
1060 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1061 *ret_copy = CResult_CommitmentTransactionDecodeErrorZ_get_err(owner_conv);
1062 uint64_t ret_ref = tag_ptr(ret_copy, true);
1066 static inline struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
1067 LDKTrustedCommitmentTransaction ret = *owner->contents.result;
1068 ret.is_owned = false;
1071 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(uint64_t owner) {
1072 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
1073 LDKTrustedCommitmentTransaction ret_var = CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner_conv);
1074 uint64_t ret_ref = 0;
1075 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1076 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1080 static inline void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
1081 CHECK(!owner->result_ok);
1082 return *owner->contents.err;
1084 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(uint64_t owner) {
1085 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
1086 CResult_TrustedCommitmentTransactionNoneZ_get_err(owner_conv);
1089 static inline struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
1090 CHECK(owner->result_ok);
1091 return *owner->contents.result;
1093 ptrArray __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_ok"))) TS_CResult_CVec_SignatureZNoneZ_get_ok(uint64_t owner) {
1094 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(owner);
1095 LDKCVec_SignatureZ ret_var = CResult_CVec_SignatureZNoneZ_get_ok(owner_conv);
1096 ptrArray ret_arr = NULL;
1097 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
1098 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
1099 for (size_t m = 0; m < ret_var.datalen; m++) {
1100 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
1101 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
1102 ret_arr_ptr[m] = ret_conv_12_arr;
1108 static inline void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
1109 CHECK(!owner->result_ok);
1110 return *owner->contents.err;
1112 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_err"))) TS_CResult_CVec_SignatureZNoneZ_get_err(uint64_t owner) {
1113 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(owner);
1114 CResult_CVec_SignatureZNoneZ_get_err(owner_conv);
1117 static inline struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
1118 LDKShutdownScript ret = *owner->contents.result;
1119 ret.is_owned = false;
1122 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(uint64_t owner) {
1123 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
1124 LDKShutdownScript ret_var = CResult_ShutdownScriptDecodeErrorZ_get_ok(owner_conv);
1125 uint64_t ret_ref = 0;
1126 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1127 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1131 static inline struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
1132 CHECK(!owner->result_ok);
1133 return DecodeError_clone(&*owner->contents.err);
1135 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_err(uint64_t owner) {
1136 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
1137 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1138 *ret_copy = CResult_ShutdownScriptDecodeErrorZ_get_err(owner_conv);
1139 uint64_t ret_ref = tag_ptr(ret_copy, true);
1143 static inline struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
1144 LDKShutdownScript ret = *owner->contents.result;
1145 ret.is_owned = false;
1148 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint64_t owner) {
1149 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
1150 LDKShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner_conv);
1151 uint64_t ret_ref = 0;
1152 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1153 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1157 static inline struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
1158 LDKInvalidShutdownScript ret = *owner->contents.err;
1159 ret.is_owned = false;
1162 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(uint64_t owner) {
1163 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
1164 LDKInvalidShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner_conv);
1165 uint64_t ret_ref = 0;
1166 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1167 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1171 static inline struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner){
1172 LDKBlindedPayInfo ret = *owner->contents.result;
1173 ret.is_owned = false;
1176 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(uint64_t owner) {
1177 LDKCResult_BlindedPayInfoDecodeErrorZ* owner_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(owner);
1178 LDKBlindedPayInfo ret_var = CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner_conv);
1179 uint64_t ret_ref = 0;
1180 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1181 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1185 static inline struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner){
1186 CHECK(!owner->result_ok);
1187 return DecodeError_clone(&*owner->contents.err);
1189 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_get_err"))) TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(uint64_t owner) {
1190 LDKCResult_BlindedPayInfoDecodeErrorZ* owner_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(owner);
1191 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1192 *ret_copy = CResult_BlindedPayInfoDecodeErrorZ_get_err(owner_conv);
1193 uint64_t ret_ref = tag_ptr(ret_copy, true);
1197 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
1198 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
1199 for (size_t i = 0; i < ret.datalen; i++) {
1200 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
1204 static inline struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1205 LDKRoute ret = *owner->contents.result;
1206 ret.is_owned = false;
1209 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_ok"))) TS_CResult_RouteLightningErrorZ_get_ok(uint64_t owner) {
1210 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
1211 LDKRoute ret_var = CResult_RouteLightningErrorZ_get_ok(owner_conv);
1212 uint64_t ret_ref = 0;
1213 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1214 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1218 static inline struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1219 LDKLightningError ret = *owner->contents.err;
1220 ret.is_owned = false;
1223 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_err"))) TS_CResult_RouteLightningErrorZ_get_err(uint64_t owner) {
1224 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
1225 LDKLightningError ret_var = CResult_RouteLightningErrorZ_get_err(owner_conv);
1226 uint64_t ret_ref = 0;
1227 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1228 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1232 static inline struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
1233 LDKInFlightHtlcs ret = *owner->contents.result;
1234 ret.is_owned = false;
1237 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(uint64_t owner) {
1238 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
1239 LDKInFlightHtlcs ret_var = CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner_conv);
1240 uint64_t ret_ref = 0;
1241 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1242 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1246 static inline struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
1247 CHECK(!owner->result_ok);
1248 return DecodeError_clone(&*owner->contents.err);
1250 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(uint64_t owner) {
1251 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
1252 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1253 *ret_copy = CResult_InFlightHtlcsDecodeErrorZ_get_err(owner_conv);
1254 uint64_t ret_ref = tag_ptr(ret_copy, true);
1258 static inline struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1259 LDKRouteHop ret = *owner->contents.result;
1260 ret.is_owned = false;
1263 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHopDecodeErrorZ_get_ok(uint64_t owner) {
1264 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
1265 LDKRouteHop ret_var = CResult_RouteHopDecodeErrorZ_get_ok(owner_conv);
1266 uint64_t ret_ref = 0;
1267 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1268 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1272 static inline struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1273 CHECK(!owner->result_ok);
1274 return DecodeError_clone(&*owner->contents.err);
1276 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_err"))) TS_CResult_RouteHopDecodeErrorZ_get_err(uint64_t owner) {
1277 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
1278 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1279 *ret_copy = CResult_RouteHopDecodeErrorZ_get_err(owner_conv);
1280 uint64_t ret_ref = tag_ptr(ret_copy, true);
1284 static inline LDKCVec_BlindedHopZ CVec_BlindedHopZ_clone(const LDKCVec_BlindedHopZ *orig) {
1285 LDKCVec_BlindedHopZ ret = { .data = MALLOC(sizeof(LDKBlindedHop) * orig->datalen, "LDKCVec_BlindedHopZ clone bytes"), .datalen = orig->datalen };
1286 for (size_t i = 0; i < ret.datalen; i++) {
1287 ret.data[i] = BlindedHop_clone(&orig->data[i]);
1291 static inline struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner){
1292 LDKBlindedTail ret = *owner->contents.result;
1293 ret.is_owned = false;
1296 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_get_ok"))) TS_CResult_BlindedTailDecodeErrorZ_get_ok(uint64_t owner) {
1297 LDKCResult_BlindedTailDecodeErrorZ* owner_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(owner);
1298 LDKBlindedTail ret_var = CResult_BlindedTailDecodeErrorZ_get_ok(owner_conv);
1299 uint64_t ret_ref = 0;
1300 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1301 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1305 static inline struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner){
1306 CHECK(!owner->result_ok);
1307 return DecodeError_clone(&*owner->contents.err);
1309 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_get_err"))) TS_CResult_BlindedTailDecodeErrorZ_get_err(uint64_t owner) {
1310 LDKCResult_BlindedTailDecodeErrorZ* owner_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(owner);
1311 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1312 *ret_copy = CResult_BlindedTailDecodeErrorZ_get_err(owner_conv);
1313 uint64_t ret_ref = tag_ptr(ret_copy, true);
1317 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
1318 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
1319 for (size_t i = 0; i < ret.datalen; i++) {
1320 ret.data[i] = RouteHop_clone(&orig->data[i]);
1324 static inline LDKCVec_PathZ CVec_PathZ_clone(const LDKCVec_PathZ *orig) {
1325 LDKCVec_PathZ ret = { .data = MALLOC(sizeof(LDKPath) * orig->datalen, "LDKCVec_PathZ clone bytes"), .datalen = orig->datalen };
1326 for (size_t i = 0; i < ret.datalen; i++) {
1327 ret.data[i] = Path_clone(&orig->data[i]);
1331 static inline struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1332 LDKRoute ret = *owner->contents.result;
1333 ret.is_owned = false;
1336 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_ok"))) TS_CResult_RouteDecodeErrorZ_get_ok(uint64_t owner) {
1337 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
1338 LDKRoute ret_var = CResult_RouteDecodeErrorZ_get_ok(owner_conv);
1339 uint64_t ret_ref = 0;
1340 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1341 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1345 static inline struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1346 CHECK(!owner->result_ok);
1347 return DecodeError_clone(&*owner->contents.err);
1349 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_err"))) TS_CResult_RouteDecodeErrorZ_get_err(uint64_t owner) {
1350 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
1351 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1352 *ret_copy = CResult_RouteDecodeErrorZ_get_err(owner_conv);
1353 uint64_t ret_ref = tag_ptr(ret_copy, true);
1357 static inline struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1358 LDKRouteParameters ret = *owner->contents.result;
1359 ret.is_owned = false;
1362 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_ok"))) TS_CResult_RouteParametersDecodeErrorZ_get_ok(uint64_t owner) {
1363 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
1364 LDKRouteParameters ret_var = CResult_RouteParametersDecodeErrorZ_get_ok(owner_conv);
1365 uint64_t ret_ref = 0;
1366 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1367 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1371 static inline struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1372 CHECK(!owner->result_ok);
1373 return DecodeError_clone(&*owner->contents.err);
1375 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_err"))) TS_CResult_RouteParametersDecodeErrorZ_get_err(uint64_t owner) {
1376 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
1377 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1378 *ret_copy = CResult_RouteParametersDecodeErrorZ_get_err(owner_conv);
1379 uint64_t ret_ref = tag_ptr(ret_copy, true);
1383 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
1384 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
1385 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
1388 static inline struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1389 LDKPaymentParameters ret = *owner->contents.result;
1390 ret.is_owned = false;
1393 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_get_ok(uint64_t owner) {
1394 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
1395 LDKPaymentParameters ret_var = CResult_PaymentParametersDecodeErrorZ_get_ok(owner_conv);
1396 uint64_t ret_ref = 0;
1397 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1398 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1402 static inline struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1403 CHECK(!owner->result_ok);
1404 return DecodeError_clone(&*owner->contents.err);
1406 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_err"))) TS_CResult_PaymentParametersDecodeErrorZ_get_err(uint64_t owner) {
1407 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
1408 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1409 *ret_copy = CResult_PaymentParametersDecodeErrorZ_get_err(owner_conv);
1410 uint64_t ret_ref = tag_ptr(ret_copy, true);
1414 static inline struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner){
1415 LDKBlindedPayInfo ret = owner->a;
1416 ret.is_owned = false;
1419 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(uint64_t owner) {
1420 LDKC2Tuple_BlindedPayInfoBlindedPathZ* owner_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(owner);
1421 LDKBlindedPayInfo ret_var = C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner_conv);
1422 uint64_t ret_ref = 0;
1423 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1424 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1428 static inline struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner){
1429 LDKBlindedPath ret = owner->b;
1430 ret.is_owned = false;
1433 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(uint64_t owner) {
1434 LDKC2Tuple_BlindedPayInfoBlindedPathZ* owner_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(owner);
1435 LDKBlindedPath ret_var = C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner_conv);
1436 uint64_t ret_ref = 0;
1437 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1438 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1442 static inline LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_clone(const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ *orig) {
1443 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ) * orig->datalen, "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ clone bytes"), .datalen = orig->datalen };
1444 for (size_t i = 0; i < ret.datalen; i++) {
1445 ret.data[i] = C2Tuple_BlindedPayInfoBlindedPathZ_clone(&orig->data[i]);
1449 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
1450 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
1451 for (size_t i = 0; i < ret.datalen; i++) {
1452 ret.data[i] = RouteHint_clone(&orig->data[i]);
1456 static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
1457 LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
1458 for (size_t i = 0; i < ret.datalen; i++) {
1459 ret.data[i] = RouteHintHop_clone(&orig->data[i]);
1463 static inline struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1464 LDKRouteHint ret = *owner->contents.result;
1465 ret.is_owned = false;
1468 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_ok"))) TS_CResult_RouteHintDecodeErrorZ_get_ok(uint64_t owner) {
1469 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
1470 LDKRouteHint ret_var = CResult_RouteHintDecodeErrorZ_get_ok(owner_conv);
1471 uint64_t ret_ref = 0;
1472 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1473 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1477 static inline struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1478 CHECK(!owner->result_ok);
1479 return DecodeError_clone(&*owner->contents.err);
1481 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_err"))) TS_CResult_RouteHintDecodeErrorZ_get_err(uint64_t owner) {
1482 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
1483 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1484 *ret_copy = CResult_RouteHintDecodeErrorZ_get_err(owner_conv);
1485 uint64_t ret_ref = tag_ptr(ret_copy, true);
1489 static inline struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1490 LDKRouteHintHop ret = *owner->contents.result;
1491 ret.is_owned = false;
1494 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_get_ok(uint64_t owner) {
1495 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
1496 LDKRouteHintHop ret_var = CResult_RouteHintHopDecodeErrorZ_get_ok(owner_conv);
1497 uint64_t ret_ref = 0;
1498 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1499 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1503 static inline struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1504 CHECK(!owner->result_ok);
1505 return DecodeError_clone(&*owner->contents.err);
1507 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_err"))) TS_CResult_RouteHintHopDecodeErrorZ_get_err(uint64_t owner) {
1508 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
1509 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1510 *ret_copy = CResult_RouteHintHopDecodeErrorZ_get_err(owner_conv);
1511 uint64_t ret_ref = tag_ptr(ret_copy, true);
1515 static inline uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
1518 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_a"))) TS_C2Tuple_usizeTransactionZ_get_a(uint64_t owner) {
1519 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
1520 uint32_t ret_conv = C2Tuple_usizeTransactionZ_get_a(owner_conv);
1524 static inline struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
1527 int8_tArray __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_b"))) TS_C2Tuple_usizeTransactionZ_get_b(uint64_t owner) {
1528 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
1529 LDKTransaction ret_var = C2Tuple_usizeTransactionZ_get_b(owner_conv);
1530 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
1531 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
1535 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
1536 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
1537 for (size_t i = 0; i < ret.datalen; i++) {
1538 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
1542 static inline struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_a(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner){
1543 return ThirtyTwoBytes_clone(&owner->a);
1545 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_get_a"))) TS_C2Tuple_TxidBlockHashZ_get_a(uint64_t owner) {
1546 LDKC2Tuple_TxidBlockHashZ* owner_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(owner);
1547 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1548 memcpy(ret_arr->elems, C2Tuple_TxidBlockHashZ_get_a(owner_conv).data, 32);
1552 static inline struct LDKThirtyTwoBytes C2Tuple_TxidBlockHashZ_get_b(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR owner){
1553 return ThirtyTwoBytes_clone(&owner->b);
1555 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_get_b"))) TS_C2Tuple_TxidBlockHashZ_get_b(uint64_t owner) {
1556 LDKC2Tuple_TxidBlockHashZ* owner_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(owner);
1557 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1558 memcpy(ret_arr->elems, C2Tuple_TxidBlockHashZ_get_b(owner_conv).data, 32);
1562 static inline LDKCVec_C2Tuple_TxidBlockHashZZ CVec_C2Tuple_TxidBlockHashZZ_clone(const LDKCVec_C2Tuple_TxidBlockHashZZ *orig) {
1563 LDKCVec_C2Tuple_TxidBlockHashZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ) * orig->datalen, "LDKCVec_C2Tuple_TxidBlockHashZZ clone bytes"), .datalen = orig->datalen };
1564 for (size_t i = 0; i < ret.datalen; i++) {
1565 ret.data[i] = C2Tuple_TxidBlockHashZ_clone(&orig->data[i]);
1569 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_ty_from_ptr"))) TS_LDKMonitorEvent_ty_from_ptr(uint64_t ptr) {
1570 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1572 case LDKMonitorEvent_HTLCEvent: return 0;
1573 case LDKMonitorEvent_CommitmentTxConfirmed: return 1;
1574 case LDKMonitorEvent_Completed: return 2;
1575 case LDKMonitorEvent_UpdateFailed: return 3;
1579 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_HTLCEvent_get_htlc_event"))) TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(uint64_t ptr) {
1580 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1581 assert(obj->tag == LDKMonitorEvent_HTLCEvent);
1582 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
1583 uint64_t htlc_event_ref = 0;
1584 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
1585 htlc_event_ref = tag_ptr(htlc_event_var.inner, false);
1586 return htlc_event_ref;
1588 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed"))) TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(uint64_t ptr) {
1589 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1590 assert(obj->tag == LDKMonitorEvent_CommitmentTxConfirmed);
1591 LDKOutPoint commitment_tx_confirmed_var = obj->commitment_tx_confirmed;
1592 uint64_t commitment_tx_confirmed_ref = 0;
1593 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
1594 commitment_tx_confirmed_ref = tag_ptr(commitment_tx_confirmed_var.inner, false);
1595 return commitment_tx_confirmed_ref;
1597 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_funding_txo"))) TS_LDKMonitorEvent_Completed_get_funding_txo(uint64_t ptr) {
1598 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1599 assert(obj->tag == LDKMonitorEvent_Completed);
1600 LDKOutPoint funding_txo_var = obj->completed.funding_txo;
1601 uint64_t funding_txo_ref = 0;
1602 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
1603 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
1604 return funding_txo_ref;
1606 int64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_monitor_update_id"))) TS_LDKMonitorEvent_Completed_get_monitor_update_id(uint64_t ptr) {
1607 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1608 assert(obj->tag == LDKMonitorEvent_Completed);
1609 int64_t monitor_update_id_conv = obj->completed.monitor_update_id;
1610 return monitor_update_id_conv;
1612 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_UpdateFailed_get_update_failed"))) TS_LDKMonitorEvent_UpdateFailed_get_update_failed(uint64_t ptr) {
1613 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
1614 assert(obj->tag == LDKMonitorEvent_UpdateFailed);
1615 LDKOutPoint update_failed_var = obj->update_failed;
1616 uint64_t update_failed_ref = 0;
1617 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
1618 update_failed_ref = tag_ptr(update_failed_var.inner, false);
1619 return update_failed_ref;
1621 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
1622 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
1623 for (size_t i = 0; i < ret.datalen; i++) {
1624 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
1628 static inline struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
1629 LDKOutPoint ret = owner->a;
1630 ret.is_owned = false;
1633 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(uint64_t owner) {
1634 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
1635 LDKOutPoint ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner_conv);
1636 uint64_t ret_ref = 0;
1637 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1638 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1642 static inline struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
1643 return CVec_MonitorEventZ_clone(&owner->b);
1645 uint64_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(uint64_t owner) {
1646 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
1647 LDKCVec_MonitorEventZ ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner_conv);
1648 uint64_tArray ret_arr = NULL;
1649 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
1650 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
1651 for (size_t o = 0; o < ret_var.datalen; o++) {
1652 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
1653 *ret_conv_14_copy = ret_var.data[o];
1654 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
1655 ret_arr_ptr[o] = ret_conv_14_ref;
1662 static inline struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
1665 int8_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(uint64_t owner) {
1666 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
1667 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
1668 memcpy(ret_arr->elems, C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner_conv).compressed_form, 33);
1672 static inline LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_clone(const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ *orig) {
1673 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ) * orig->datalen, "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ clone bytes"), .datalen = orig->datalen };
1674 for (size_t i = 0; i < ret.datalen; i++) {
1675 ret.data[i] = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(&orig->data[i]);
1679 static inline struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
1680 LDKFixedPenaltyScorer ret = *owner->contents.result;
1681 ret.is_owned = false;
1684 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(uint64_t owner) {
1685 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
1686 LDKFixedPenaltyScorer ret_var = CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner_conv);
1687 uint64_t ret_ref = 0;
1688 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1689 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1693 static inline struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
1694 CHECK(!owner->result_ok);
1695 return DecodeError_clone(&*owner->contents.err);
1697 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(uint64_t owner) {
1698 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
1699 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1700 *ret_copy = CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner_conv);
1701 uint64_t ret_ref = tag_ptr(ret_copy, true);
1705 static inline uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
1708 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_a"))) TS_C2Tuple_u64u64Z_get_a(uint64_t owner) {
1709 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
1710 int64_t ret_conv = C2Tuple_u64u64Z_get_a(owner_conv);
1714 static inline uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
1717 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_b"))) TS_C2Tuple_u64u64Z_get_b(uint64_t owner) {
1718 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
1719 int64_t ret_conv = C2Tuple_u64u64Z_get_b(owner_conv);
1723 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(uint64_t ptr) {
1724 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
1726 case LDKCOption_C2Tuple_u64u64ZZ_Some: return 0;
1727 case LDKCOption_C2Tuple_u64u64ZZ_None: return 1;
1731 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(uint64_t ptr) {
1732 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
1733 assert(obj->tag == LDKCOption_C2Tuple_u64u64ZZ_Some);
1734 LDKC2Tuple_u64u64Z* some_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
1735 *some_conv = obj->some;
1736 *some_conv = C2Tuple_u64u64Z_clone(some_conv);
1737 return tag_ptr(some_conv, true);
1739 static inline struct LDKEightU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner){
1742 int16_tArray __attribute__((export_name("TS_C2Tuple_Z_get_a"))) TS_C2Tuple_Z_get_a(uint64_t owner) {
1743 LDKC2Tuple_Z* owner_conv = (LDKC2Tuple_Z*)untag_ptr(owner);
1744 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1745 memcpy(ret_arr->elems, C2Tuple_Z_get_a(owner_conv).data, 8 * 2);
1749 static inline struct LDKEightU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner){
1752 int16_tArray __attribute__((export_name("TS_C2Tuple_Z_get_b"))) TS_C2Tuple_Z_get_b(uint64_t owner) {
1753 LDKC2Tuple_Z* owner_conv = (LDKC2Tuple_Z*)untag_ptr(owner);
1754 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1755 memcpy(ret_arr->elems, C2Tuple_Z_get_b(owner_conv).data, 8 * 2);
1759 static inline struct LDKEightU16s C2Tuple__u168_u168Z_get_a(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner){
1762 int16_tArray __attribute__((export_name("TS_C2Tuple__u168_u168Z_get_a"))) TS_C2Tuple__u168_u168Z_get_a(uint64_t owner) {
1763 LDKC2Tuple__u168_u168Z* owner_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(owner);
1764 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1765 memcpy(ret_arr->elems, C2Tuple__u168_u168Z_get_a(owner_conv).data, 8 * 2);
1769 static inline struct LDKEightU16s C2Tuple__u168_u168Z_get_b(LDKC2Tuple__u168_u168Z *NONNULL_PTR owner){
1772 int16_tArray __attribute__((export_name("TS_C2Tuple__u168_u168Z_get_b"))) TS_C2Tuple__u168_u168Z_get_b(uint64_t owner) {
1773 LDKC2Tuple__u168_u168Z* owner_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(owner);
1774 int16_tArray ret_arr = init_int16_tArray(8, __LINE__);
1775 memcpy(ret_arr->elems, C2Tuple__u168_u168Z_get_b(owner_conv).data, 8 * 2);
1779 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_ty_from_ptr(uint64_t ptr) {
1780 LDKCOption_C2Tuple_EightU16sEightU16sZZ *obj = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(ptr);
1782 case LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some: return 0;
1783 case LDKCOption_C2Tuple_EightU16sEightU16sZZ_None: return 1;
1787 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some_get_some(uint64_t ptr) {
1788 LDKCOption_C2Tuple_EightU16sEightU16sZZ *obj = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(ptr);
1789 assert(obj->tag == LDKCOption_C2Tuple_EightU16sEightU16sZZ_Some);
1790 LDKC2Tuple__u168_u168Z* some_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
1791 *some_conv = obj->some;
1792 *some_conv = C2Tuple__u168_u168Z_clone(some_conv);
1793 return tag_ptr(some_conv, true);
1795 static inline LDKCVec_NodeIdZ CVec_NodeIdZ_clone(const LDKCVec_NodeIdZ *orig) {
1796 LDKCVec_NodeIdZ ret = { .data = MALLOC(sizeof(LDKNodeId) * orig->datalen, "LDKCVec_NodeIdZ clone bytes"), .datalen = orig->datalen };
1797 for (size_t i = 0; i < ret.datalen; i++) {
1798 ret.data[i] = NodeId_clone(&orig->data[i]);
1802 typedef struct LDKLogger_JCalls {
1803 atomic_size_t refcnt;
1804 uint32_t instance_ptr;
1806 static void LDKLogger_JCalls_free(void* this_arg) {
1807 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
1808 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
1812 void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
1813 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
1814 LDKRecord record_var = *record;
1815 uint64_t record_ref = 0;
1816 record_var = Record_clone(&record_var);
1817 CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
1818 record_ref = tag_ptr(record_var.inner, record_var.is_owned);
1819 js_invoke_function_buuuuu(j_calls->instance_ptr, 0, record_ref, 0, 0, 0, 0, 0);
1821 static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
1822 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
1823 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
1825 static inline LDKLogger LDKLogger_init (JSValue o) {
1826 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
1827 atomic_init(&calls->refcnt, 1);
1828 calls->instance_ptr = o;
1831 .this_arg = (void*) calls,
1832 .log = log_LDKLogger_jcall,
1833 .free = LDKLogger_JCalls_free,
1837 uint64_t __attribute__((export_name("TS_LDKLogger_new"))) TS_LDKLogger_new(JSValue o) {
1838 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
1839 *res_ptr = LDKLogger_init(o);
1840 return tag_ptr(res_ptr, true);
1842 static inline struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
1843 LDKProbabilisticScorer ret = *owner->contents.result;
1844 ret.is_owned = false;
1847 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(uint64_t owner) {
1848 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
1849 LDKProbabilisticScorer ret_var = CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner_conv);
1850 uint64_t ret_ref = 0;
1851 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1852 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1856 static inline struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
1857 CHECK(!owner->result_ok);
1858 return DecodeError_clone(&*owner->contents.err);
1860 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(uint64_t owner) {
1861 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
1862 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1863 *ret_copy = CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner_conv);
1864 uint64_t ret_ref = tag_ptr(ret_copy, true);
1868 static inline struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
1869 LDKInitFeatures ret = *owner->contents.result;
1870 ret.is_owned = false;
1873 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1874 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
1875 LDKInitFeatures ret_var = CResult_InitFeaturesDecodeErrorZ_get_ok(owner_conv);
1876 uint64_t ret_ref = 0;
1877 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1878 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1882 static inline struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
1883 CHECK(!owner->result_ok);
1884 return DecodeError_clone(&*owner->contents.err);
1886 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_err"))) TS_CResult_InitFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1887 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
1888 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1889 *ret_copy = CResult_InitFeaturesDecodeErrorZ_get_err(owner_conv);
1890 uint64_t ret_ref = tag_ptr(ret_copy, true);
1894 static inline struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
1895 LDKChannelFeatures ret = *owner->contents.result;
1896 ret.is_owned = false;
1899 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1900 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
1901 LDKChannelFeatures ret_var = CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner_conv);
1902 uint64_t ret_ref = 0;
1903 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1904 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1908 static inline struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
1909 CHECK(!owner->result_ok);
1910 return DecodeError_clone(&*owner->contents.err);
1912 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1913 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
1914 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1915 *ret_copy = CResult_ChannelFeaturesDecodeErrorZ_get_err(owner_conv);
1916 uint64_t ret_ref = tag_ptr(ret_copy, true);
1920 static inline struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
1921 LDKNodeFeatures ret = *owner->contents.result;
1922 ret.is_owned = false;
1925 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1926 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
1927 LDKNodeFeatures ret_var = CResult_NodeFeaturesDecodeErrorZ_get_ok(owner_conv);
1928 uint64_t ret_ref = 0;
1929 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1930 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1934 static inline struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
1935 CHECK(!owner->result_ok);
1936 return DecodeError_clone(&*owner->contents.err);
1938 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1939 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
1940 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1941 *ret_copy = CResult_NodeFeaturesDecodeErrorZ_get_err(owner_conv);
1942 uint64_t ret_ref = tag_ptr(ret_copy, true);
1946 static inline struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
1947 LDKInvoiceFeatures ret = *owner->contents.result;
1948 ret.is_owned = false;
1951 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1952 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
1953 LDKInvoiceFeatures ret_var = CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner_conv);
1954 uint64_t ret_ref = 0;
1955 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1956 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1960 static inline struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
1961 CHECK(!owner->result_ok);
1962 return DecodeError_clone(&*owner->contents.err);
1964 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1965 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
1966 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1967 *ret_copy = CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner_conv);
1968 uint64_t ret_ref = tag_ptr(ret_copy, true);
1972 static inline struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner){
1973 LDKBlindedHopFeatures ret = *owner->contents.result;
1974 ret.is_owned = false;
1977 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
1978 LDKCResult_BlindedHopFeaturesDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(owner);
1979 LDKBlindedHopFeatures ret_var = CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner_conv);
1980 uint64_t ret_ref = 0;
1981 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1982 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1986 static inline struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner){
1987 CHECK(!owner->result_ok);
1988 return DecodeError_clone(&*owner->contents.err);
1990 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(uint64_t owner) {
1991 LDKCResult_BlindedHopFeaturesDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(owner);
1992 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1993 *ret_copy = CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner_conv);
1994 uint64_t ret_ref = tag_ptr(ret_copy, true);
1998 static inline struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
1999 LDKChannelTypeFeatures ret = *owner->contents.result;
2000 ret.is_owned = false;
2003 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2004 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
2005 LDKChannelTypeFeatures ret_var = CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner_conv);
2006 uint64_t ret_ref = 0;
2007 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2008 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2012 static inline struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
2013 CHECK(!owner->result_ok);
2014 return DecodeError_clone(&*owner->contents.err);
2016 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2017 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
2018 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2019 *ret_copy = CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner_conv);
2020 uint64_t ret_ref = tag_ptr(ret_copy, true);
2024 uint32_t __attribute__((export_name("TS_LDKPaymentPurpose_ty_from_ptr"))) TS_LDKPaymentPurpose_ty_from_ptr(uint64_t ptr) {
2025 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2027 case LDKPaymentPurpose_InvoicePayment: return 0;
2028 case LDKPaymentPurpose_SpontaneousPayment: return 1;
2032 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(uint64_t ptr) {
2033 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2034 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
2035 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
2036 memcpy(payment_preimage_arr->elems, obj->invoice_payment.payment_preimage.data, 32);
2037 return payment_preimage_arr;
2039 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(uint64_t ptr) {
2040 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2041 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
2042 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
2043 memcpy(payment_secret_arr->elems, obj->invoice_payment.payment_secret.data, 32);
2044 return payment_secret_arr;
2046 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment"))) TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(uint64_t ptr) {
2047 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
2048 assert(obj->tag == LDKPaymentPurpose_SpontaneousPayment);
2049 int8_tArray spontaneous_payment_arr = init_int8_tArray(32, __LINE__);
2050 memcpy(spontaneous_payment_arr->elems, obj->spontaneous_payment.data, 32);
2051 return spontaneous_payment_arr;
2053 static inline struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
2054 CHECK(owner->result_ok);
2055 return PaymentPurpose_clone(&*owner->contents.result);
2057 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(uint64_t owner) {
2058 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
2059 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
2060 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_ok(owner_conv);
2061 uint64_t ret_ref = tag_ptr(ret_copy, true);
2065 static inline struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
2066 CHECK(!owner->result_ok);
2067 return DecodeError_clone(&*owner->contents.err);
2069 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_err(uint64_t owner) {
2070 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
2071 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2072 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_err(owner_conv);
2073 uint64_t ret_ref = tag_ptr(ret_copy, true);
2077 uint32_t __attribute__((export_name("TS_LDKNetworkUpdate_ty_from_ptr"))) TS_LDKNetworkUpdate_ty_from_ptr(uint64_t ptr) {
2078 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2080 case LDKNetworkUpdate_ChannelUpdateMessage: return 0;
2081 case LDKNetworkUpdate_ChannelFailure: return 1;
2082 case LDKNetworkUpdate_NodeFailure: return 2;
2086 uint64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg"))) TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(uint64_t ptr) {
2087 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2088 assert(obj->tag == LDKNetworkUpdate_ChannelUpdateMessage);
2089 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
2090 uint64_t msg_ref = 0;
2091 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2092 msg_ref = tag_ptr(msg_var.inner, false);
2095 int64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id"))) TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(uint64_t ptr) {
2096 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2097 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
2098 int64_t short_channel_id_conv = obj->channel_failure.short_channel_id;
2099 return short_channel_id_conv;
2101 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent"))) TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(uint64_t ptr) {
2102 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2103 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
2104 jboolean is_permanent_conv = obj->channel_failure.is_permanent;
2105 return is_permanent_conv;
2107 int8_tArray __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_node_id"))) TS_LDKNetworkUpdate_NodeFailure_get_node_id(uint64_t ptr) {
2108 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2109 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
2110 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2111 memcpy(node_id_arr->elems, obj->node_failure.node_id.compressed_form, 33);
2114 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_is_permanent"))) TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(uint64_t ptr) {
2115 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
2116 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
2117 jboolean is_permanent_conv = obj->node_failure.is_permanent;
2118 return is_permanent_conv;
2120 uint32_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_ty_from_ptr"))) TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(uint64_t ptr) {
2121 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
2123 case LDKCOption_NetworkUpdateZ_Some: return 0;
2124 case LDKCOption_NetworkUpdateZ_None: return 1;
2128 uint64_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_Some_get_some"))) TS_LDKCOption_NetworkUpdateZ_Some_get_some(uint64_t ptr) {
2129 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
2130 assert(obj->tag == LDKCOption_NetworkUpdateZ_Some);
2131 uint64_t some_ref = tag_ptr(&obj->some, false);
2134 uint32_t __attribute__((export_name("TS_LDKPathFailure_ty_from_ptr"))) TS_LDKPathFailure_ty_from_ptr(uint64_t ptr) {
2135 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
2137 case LDKPathFailure_InitialSend: return 0;
2138 case LDKPathFailure_OnPath: return 1;
2142 uint64_t __attribute__((export_name("TS_LDKPathFailure_InitialSend_get_err"))) TS_LDKPathFailure_InitialSend_get_err(uint64_t ptr) {
2143 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
2144 assert(obj->tag == LDKPathFailure_InitialSend);
2145 uint64_t err_ref = tag_ptr(&obj->initial_send.err, false);
2148 uint64_t __attribute__((export_name("TS_LDKPathFailure_OnPath_get_network_update"))) TS_LDKPathFailure_OnPath_get_network_update(uint64_t ptr) {
2149 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
2150 assert(obj->tag == LDKPathFailure_OnPath);
2151 uint64_t network_update_ref = tag_ptr(&obj->on_path.network_update, false);
2152 return network_update_ref;
2154 uint32_t __attribute__((export_name("TS_LDKCOption_PathFailureZ_ty_from_ptr"))) TS_LDKCOption_PathFailureZ_ty_from_ptr(uint64_t ptr) {
2155 LDKCOption_PathFailureZ *obj = (LDKCOption_PathFailureZ*)untag_ptr(ptr);
2157 case LDKCOption_PathFailureZ_Some: return 0;
2158 case LDKCOption_PathFailureZ_None: return 1;
2162 uint64_t __attribute__((export_name("TS_LDKCOption_PathFailureZ_Some_get_some"))) TS_LDKCOption_PathFailureZ_Some_get_some(uint64_t ptr) {
2163 LDKCOption_PathFailureZ *obj = (LDKCOption_PathFailureZ*)untag_ptr(ptr);
2164 assert(obj->tag == LDKCOption_PathFailureZ_Some);
2165 uint64_t some_ref = tag_ptr(&obj->some, false);
2168 static inline struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner){
2169 CHECK(owner->result_ok);
2170 return COption_PathFailureZ_clone(&*owner->contents.result);
2172 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(uint64_t owner) {
2173 LDKCResult_COption_PathFailureZDecodeErrorZ* owner_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(owner);
2174 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
2175 *ret_copy = CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner_conv);
2176 uint64_t ret_ref = tag_ptr(ret_copy, true);
2180 static inline struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner){
2181 CHECK(!owner->result_ok);
2182 return DecodeError_clone(&*owner->contents.err);
2184 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_get_err"))) TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(uint64_t owner) {
2185 LDKCResult_COption_PathFailureZDecodeErrorZ* owner_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(owner);
2186 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2187 *ret_copy = CResult_COption_PathFailureZDecodeErrorZ_get_err(owner_conv);
2188 uint64_t ret_ref = tag_ptr(ret_copy, true);
2192 uint32_t __attribute__((export_name("TS_LDKClosureReason_ty_from_ptr"))) TS_LDKClosureReason_ty_from_ptr(uint64_t ptr) {
2193 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
2195 case LDKClosureReason_CounterpartyForceClosed: return 0;
2196 case LDKClosureReason_HolderForceClosed: return 1;
2197 case LDKClosureReason_CooperativeClosure: return 2;
2198 case LDKClosureReason_CommitmentTxConfirmed: return 3;
2199 case LDKClosureReason_FundingTimedOut: return 4;
2200 case LDKClosureReason_ProcessingError: return 5;
2201 case LDKClosureReason_DisconnectedPeer: return 6;
2202 case LDKClosureReason_OutdatedChannelManager: return 7;
2206 uint64_t __attribute__((export_name("TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg"))) TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(uint64_t ptr) {
2207 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
2208 assert(obj->tag == LDKClosureReason_CounterpartyForceClosed);
2209 LDKUntrustedString peer_msg_var = obj->counterparty_force_closed.peer_msg;
2210 uint64_t peer_msg_ref = 0;
2211 CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_msg_var);
2212 peer_msg_ref = tag_ptr(peer_msg_var.inner, false);
2213 return peer_msg_ref;
2215 jstring __attribute__((export_name("TS_LDKClosureReason_ProcessingError_get_err"))) TS_LDKClosureReason_ProcessingError_get_err(uint64_t ptr) {
2216 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
2217 assert(obj->tag == LDKClosureReason_ProcessingError);
2218 LDKStr err_str = obj->processing_error.err;
2219 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
2222 uint32_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_ty_from_ptr"))) TS_LDKCOption_ClosureReasonZ_ty_from_ptr(uint64_t ptr) {
2223 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
2225 case LDKCOption_ClosureReasonZ_Some: return 0;
2226 case LDKCOption_ClosureReasonZ_None: return 1;
2230 uint64_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_Some_get_some"))) TS_LDKCOption_ClosureReasonZ_Some_get_some(uint64_t ptr) {
2231 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
2232 assert(obj->tag == LDKCOption_ClosureReasonZ_Some);
2233 uint64_t some_ref = tag_ptr(&obj->some, false);
2236 static inline struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
2237 CHECK(owner->result_ok);
2238 return COption_ClosureReasonZ_clone(&*owner->contents.result);
2240 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint64_t owner) {
2241 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
2242 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
2243 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner_conv);
2244 uint64_t ret_ref = tag_ptr(ret_copy, true);
2248 static inline struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
2249 CHECK(!owner->result_ok);
2250 return DecodeError_clone(&*owner->contents.err);
2252 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint64_t owner) {
2253 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
2254 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2255 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner_conv);
2256 uint64_t ret_ref = tag_ptr(ret_copy, true);
2260 uint32_t __attribute__((export_name("TS_LDKHTLCDestination_ty_from_ptr"))) TS_LDKHTLCDestination_ty_from_ptr(uint64_t ptr) {
2261 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2263 case LDKHTLCDestination_NextHopChannel: return 0;
2264 case LDKHTLCDestination_UnknownNextHop: return 1;
2265 case LDKHTLCDestination_InvalidForward: return 2;
2266 case LDKHTLCDestination_FailedPayment: return 3;
2270 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_node_id"))) TS_LDKHTLCDestination_NextHopChannel_get_node_id(uint64_t ptr) {
2271 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2272 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
2273 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2274 memcpy(node_id_arr->elems, obj->next_hop_channel.node_id.compressed_form, 33);
2277 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_channel_id"))) TS_LDKHTLCDestination_NextHopChannel_get_channel_id(uint64_t ptr) {
2278 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2279 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
2280 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2281 memcpy(channel_id_arr->elems, obj->next_hop_channel.channel_id.data, 32);
2282 return channel_id_arr;
2284 int64_t __attribute__((export_name("TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid"))) TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(uint64_t ptr) {
2285 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2286 assert(obj->tag == LDKHTLCDestination_UnknownNextHop);
2287 int64_t requested_forward_scid_conv = obj->unknown_next_hop.requested_forward_scid;
2288 return requested_forward_scid_conv;
2290 int64_t __attribute__((export_name("TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid"))) TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(uint64_t ptr) {
2291 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2292 assert(obj->tag == LDKHTLCDestination_InvalidForward);
2293 int64_t requested_forward_scid_conv = obj->invalid_forward.requested_forward_scid;
2294 return requested_forward_scid_conv;
2296 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_FailedPayment_get_payment_hash"))) TS_LDKHTLCDestination_FailedPayment_get_payment_hash(uint64_t ptr) {
2297 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
2298 assert(obj->tag == LDKHTLCDestination_FailedPayment);
2299 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2300 memcpy(payment_hash_arr->elems, obj->failed_payment.payment_hash.data, 32);
2301 return payment_hash_arr;
2303 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_ty_from_ptr"))) TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(uint64_t ptr) {
2304 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
2306 case LDKCOption_HTLCDestinationZ_Some: return 0;
2307 case LDKCOption_HTLCDestinationZ_None: return 1;
2311 uint64_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_Some_get_some"))) TS_LDKCOption_HTLCDestinationZ_Some_get_some(uint64_t ptr) {
2312 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
2313 assert(obj->tag == LDKCOption_HTLCDestinationZ_Some);
2314 uint64_t some_ref = tag_ptr(&obj->some, false);
2317 static inline struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
2318 CHECK(owner->result_ok);
2319 return COption_HTLCDestinationZ_clone(&*owner->contents.result);
2321 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(uint64_t owner) {
2322 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
2323 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
2324 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner_conv);
2325 uint64_t ret_ref = tag_ptr(ret_copy, true);
2329 static inline struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
2330 CHECK(!owner->result_ok);
2331 return DecodeError_clone(&*owner->contents.err);
2333 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(uint64_t owner) {
2334 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
2335 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2336 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner_conv);
2337 uint64_t ret_ref = tag_ptr(ret_copy, true);
2341 static inline enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner){
2342 CHECK(owner->result_ok);
2343 return PaymentFailureReason_clone(&*owner->contents.result);
2345 uint32_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(uint64_t owner) {
2346 LDKCResult_PaymentFailureReasonDecodeErrorZ* owner_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(owner);
2347 uint32_t ret_conv = LDKPaymentFailureReason_to_js(CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner_conv));
2351 static inline struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner){
2352 CHECK(!owner->result_ok);
2353 return DecodeError_clone(&*owner->contents.err);
2355 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(uint64_t owner) {
2356 LDKCResult_PaymentFailureReasonDecodeErrorZ* owner_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(owner);
2357 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2358 *ret_copy = CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner_conv);
2359 uint64_t ret_ref = tag_ptr(ret_copy, true);
2363 uint32_t __attribute__((export_name("TS_LDKCOption_u128Z_ty_from_ptr"))) TS_LDKCOption_u128Z_ty_from_ptr(uint64_t ptr) {
2364 LDKCOption_u128Z *obj = (LDKCOption_u128Z*)untag_ptr(ptr);
2366 case LDKCOption_u128Z_Some: return 0;
2367 case LDKCOption_u128Z_None: return 1;
2371 int8_tArray __attribute__((export_name("TS_LDKCOption_u128Z_Some_get_some"))) TS_LDKCOption_u128Z_Some_get_some(uint64_t ptr) {
2372 LDKCOption_u128Z *obj = (LDKCOption_u128Z*)untag_ptr(ptr);
2373 assert(obj->tag == LDKCOption_u128Z_Some);
2374 int8_tArray some_arr = init_int8_tArray(16, __LINE__);
2375 memcpy(some_arr->elems, obj->some.le_bytes, 16);
2378 uint32_t __attribute__((export_name("TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr"))) TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(uint64_t ptr) {
2379 LDKCOption_PaymentFailureReasonZ *obj = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(ptr);
2381 case LDKCOption_PaymentFailureReasonZ_Some: return 0;
2382 case LDKCOption_PaymentFailureReasonZ_None: return 1;
2386 uint32_t __attribute__((export_name("TS_LDKCOption_PaymentFailureReasonZ_Some_get_some"))) TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(uint64_t ptr) {
2387 LDKCOption_PaymentFailureReasonZ *obj = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(ptr);
2388 assert(obj->tag == LDKCOption_PaymentFailureReasonZ_Some);
2389 uint32_t some_conv = LDKPaymentFailureReason_to_js(obj->some);
2392 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_ty_from_ptr"))) TS_LDKSpendableOutputDescriptor_ty_from_ptr(uint64_t ptr) {
2393 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2395 case LDKSpendableOutputDescriptor_StaticOutput: return 0;
2396 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: return 1;
2397 case LDKSpendableOutputDescriptor_StaticPaymentOutput: return 2;
2401 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(uint64_t ptr) {
2402 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2403 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
2404 LDKOutPoint outpoint_var = obj->static_output.outpoint;
2405 uint64_t outpoint_ref = 0;
2406 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
2407 outpoint_ref = tag_ptr(outpoint_var.inner, false);
2408 return outpoint_ref;
2410 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_output"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(uint64_t ptr) {
2411 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2412 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
2413 LDKTxOut* output_ref = &obj->static_output.output;
2414 return tag_ptr(output_ref, false);
2416 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output"))) TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(uint64_t ptr) {
2417 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2418 assert(obj->tag == LDKSpendableOutputDescriptor_DelayedPaymentOutput);
2419 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
2420 uint64_t delayed_payment_output_ref = 0;
2421 CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
2422 delayed_payment_output_ref = tag_ptr(delayed_payment_output_var.inner, false);
2423 return delayed_payment_output_ref;
2425 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output"))) TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(uint64_t ptr) {
2426 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
2427 assert(obj->tag == LDKSpendableOutputDescriptor_StaticPaymentOutput);
2428 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
2429 uint64_t static_payment_output_ref = 0;
2430 CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
2431 static_payment_output_ref = tag_ptr(static_payment_output_var.inner, false);
2432 return static_payment_output_ref;
2434 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
2435 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
2436 for (size_t i = 0; i < ret.datalen; i++) {
2437 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
2441 uint32_t __attribute__((export_name("TS_LDKEvent_ty_from_ptr"))) TS_LDKEvent_ty_from_ptr(uint64_t ptr) {
2442 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2444 case LDKEvent_FundingGenerationReady: return 0;
2445 case LDKEvent_PaymentClaimable: return 1;
2446 case LDKEvent_PaymentClaimed: return 2;
2447 case LDKEvent_PaymentSent: return 3;
2448 case LDKEvent_PaymentFailed: return 4;
2449 case LDKEvent_PaymentPathSuccessful: return 5;
2450 case LDKEvent_PaymentPathFailed: return 6;
2451 case LDKEvent_ProbeSuccessful: return 7;
2452 case LDKEvent_ProbeFailed: return 8;
2453 case LDKEvent_PendingHTLCsForwardable: return 9;
2454 case LDKEvent_HTLCIntercepted: return 10;
2455 case LDKEvent_SpendableOutputs: return 11;
2456 case LDKEvent_PaymentForwarded: return 12;
2457 case LDKEvent_ChannelPending: return 13;
2458 case LDKEvent_ChannelReady: return 14;
2459 case LDKEvent_ChannelClosed: return 15;
2460 case LDKEvent_DiscardFunding: return 16;
2461 case LDKEvent_OpenChannelRequest: return 17;
2462 case LDKEvent_HTLCHandlingFailed: return 18;
2466 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(uint64_t ptr) {
2467 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2468 assert(obj->tag == LDKEvent_FundingGenerationReady);
2469 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2470 memcpy(temporary_channel_id_arr->elems, obj->funding_generation_ready.temporary_channel_id.data, 32);
2471 return temporary_channel_id_arr;
2473 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id"))) TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(uint64_t ptr) {
2474 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2475 assert(obj->tag == LDKEvent_FundingGenerationReady);
2476 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2477 memcpy(counterparty_node_id_arr->elems, obj->funding_generation_ready.counterparty_node_id.compressed_form, 33);
2478 return counterparty_node_id_arr;
2480 int64_t __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis"))) TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(uint64_t ptr) {
2481 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2482 assert(obj->tag == LDKEvent_FundingGenerationReady);
2483 int64_t channel_value_satoshis_conv = obj->funding_generation_ready.channel_value_satoshis;
2484 return channel_value_satoshis_conv;
2486 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_output_script"))) TS_LDKEvent_FundingGenerationReady_get_output_script(uint64_t ptr) {
2487 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2488 assert(obj->tag == LDKEvent_FundingGenerationReady);
2489 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
2490 int8_tArray output_script_arr = init_int8_tArray(output_script_var.datalen, __LINE__);
2491 memcpy(output_script_arr->elems, output_script_var.data, output_script_var.datalen);
2492 return output_script_arr;
2494 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_user_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_user_channel_id(uint64_t ptr) {
2495 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2496 assert(obj->tag == LDKEvent_FundingGenerationReady);
2497 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2498 memcpy(user_channel_id_arr->elems, obj->funding_generation_ready.user_channel_id.le_bytes, 16);
2499 return user_channel_id_arr;
2501 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimable_get_receiver_node_id(uint64_t ptr) {
2502 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2503 assert(obj->tag == LDKEvent_PaymentClaimable);
2504 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
2505 memcpy(receiver_node_id_arr->elems, obj->payment_claimable.receiver_node_id.compressed_form, 33);
2506 return receiver_node_id_arr;
2508 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_payment_hash"))) TS_LDKEvent_PaymentClaimable_get_payment_hash(uint64_t ptr) {
2509 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2510 assert(obj->tag == LDKEvent_PaymentClaimable);
2511 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2512 memcpy(payment_hash_arr->elems, obj->payment_claimable.payment_hash.data, 32);
2513 return payment_hash_arr;
2515 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_onion_fields"))) TS_LDKEvent_PaymentClaimable_get_onion_fields(uint64_t ptr) {
2516 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2517 assert(obj->tag == LDKEvent_PaymentClaimable);
2518 LDKRecipientOnionFields onion_fields_var = obj->payment_claimable.onion_fields;
2519 uint64_t onion_fields_ref = 0;
2520 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_fields_var);
2521 onion_fields_ref = tag_ptr(onion_fields_var.inner, false);
2522 return onion_fields_ref;
2524 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_amount_msat"))) TS_LDKEvent_PaymentClaimable_get_amount_msat(uint64_t ptr) {
2525 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2526 assert(obj->tag == LDKEvent_PaymentClaimable);
2527 int64_t amount_msat_conv = obj->payment_claimable.amount_msat;
2528 return amount_msat_conv;
2530 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_purpose"))) TS_LDKEvent_PaymentClaimable_get_purpose(uint64_t ptr) {
2531 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2532 assert(obj->tag == LDKEvent_PaymentClaimable);
2533 uint64_t purpose_ref = tag_ptr(&obj->payment_claimable.purpose, false);
2536 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_channel_id(uint64_t ptr) {
2537 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2538 assert(obj->tag == LDKEvent_PaymentClaimable);
2539 int8_tArray via_channel_id_arr = init_int8_tArray(32, __LINE__);
2540 memcpy(via_channel_id_arr->elems, obj->payment_claimable.via_channel_id.data, 32);
2541 return via_channel_id_arr;
2543 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_user_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(uint64_t ptr) {
2544 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2545 assert(obj->tag == LDKEvent_PaymentClaimable);
2546 uint64_t via_user_channel_id_ref = tag_ptr(&obj->payment_claimable.via_user_channel_id, false);
2547 return via_user_channel_id_ref;
2549 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_claim_deadline"))) TS_LDKEvent_PaymentClaimable_get_claim_deadline(uint64_t ptr) {
2550 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2551 assert(obj->tag == LDKEvent_PaymentClaimable);
2552 uint64_t claim_deadline_ref = tag_ptr(&obj->payment_claimable.claim_deadline, false);
2553 return claim_deadline_ref;
2555 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimed_get_receiver_node_id(uint64_t ptr) {
2556 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2557 assert(obj->tag == LDKEvent_PaymentClaimed);
2558 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
2559 memcpy(receiver_node_id_arr->elems, obj->payment_claimed.receiver_node_id.compressed_form, 33);
2560 return receiver_node_id_arr;
2562 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_payment_hash"))) TS_LDKEvent_PaymentClaimed_get_payment_hash(uint64_t ptr) {
2563 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2564 assert(obj->tag == LDKEvent_PaymentClaimed);
2565 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2566 memcpy(payment_hash_arr->elems, obj->payment_claimed.payment_hash.data, 32);
2567 return payment_hash_arr;
2569 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_amount_msat"))) TS_LDKEvent_PaymentClaimed_get_amount_msat(uint64_t ptr) {
2570 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2571 assert(obj->tag == LDKEvent_PaymentClaimed);
2572 int64_t amount_msat_conv = obj->payment_claimed.amount_msat;
2573 return amount_msat_conv;
2575 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_purpose"))) TS_LDKEvent_PaymentClaimed_get_purpose(uint64_t ptr) {
2576 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2577 assert(obj->tag == LDKEvent_PaymentClaimed);
2578 uint64_t purpose_ref = tag_ptr(&obj->payment_claimed.purpose, false);
2581 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_id"))) TS_LDKEvent_PaymentSent_get_payment_id(uint64_t ptr) {
2582 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2583 assert(obj->tag == LDKEvent_PaymentSent);
2584 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2585 memcpy(payment_id_arr->elems, obj->payment_sent.payment_id.data, 32);
2586 return payment_id_arr;
2588 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_preimage"))) TS_LDKEvent_PaymentSent_get_payment_preimage(uint64_t ptr) {
2589 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2590 assert(obj->tag == LDKEvent_PaymentSent);
2591 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
2592 memcpy(payment_preimage_arr->elems, obj->payment_sent.payment_preimage.data, 32);
2593 return payment_preimage_arr;
2595 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_hash"))) TS_LDKEvent_PaymentSent_get_payment_hash(uint64_t ptr) {
2596 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2597 assert(obj->tag == LDKEvent_PaymentSent);
2598 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2599 memcpy(payment_hash_arr->elems, obj->payment_sent.payment_hash.data, 32);
2600 return payment_hash_arr;
2602 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentSent_get_fee_paid_msat"))) TS_LDKEvent_PaymentSent_get_fee_paid_msat(uint64_t ptr) {
2603 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2604 assert(obj->tag == LDKEvent_PaymentSent);
2605 uint64_t fee_paid_msat_ref = tag_ptr(&obj->payment_sent.fee_paid_msat, false);
2606 return fee_paid_msat_ref;
2608 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_id"))) TS_LDKEvent_PaymentFailed_get_payment_id(uint64_t ptr) {
2609 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2610 assert(obj->tag == LDKEvent_PaymentFailed);
2611 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2612 memcpy(payment_id_arr->elems, obj->payment_failed.payment_id.data, 32);
2613 return payment_id_arr;
2615 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_hash"))) TS_LDKEvent_PaymentFailed_get_payment_hash(uint64_t ptr) {
2616 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2617 assert(obj->tag == LDKEvent_PaymentFailed);
2618 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2619 memcpy(payment_hash_arr->elems, obj->payment_failed.payment_hash.data, 32);
2620 return payment_hash_arr;
2622 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_reason"))) TS_LDKEvent_PaymentFailed_get_reason(uint64_t ptr) {
2623 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2624 assert(obj->tag == LDKEvent_PaymentFailed);
2625 uint64_t reason_ref = tag_ptr(&obj->payment_failed.reason, false);
2628 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_id"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_id(uint64_t ptr) {
2629 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2630 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
2631 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2632 memcpy(payment_id_arr->elems, obj->payment_path_successful.payment_id.data, 32);
2633 return payment_id_arr;
2635 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_hash"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(uint64_t ptr) {
2636 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2637 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
2638 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2639 memcpy(payment_hash_arr->elems, obj->payment_path_successful.payment_hash.data, 32);
2640 return payment_hash_arr;
2642 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_path"))) TS_LDKEvent_PaymentPathSuccessful_get_path(uint64_t ptr) {
2643 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2644 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
2645 LDKPath path_var = obj->payment_path_successful.path;
2646 uint64_t path_ref = 0;
2647 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2648 path_ref = tag_ptr(path_var.inner, false);
2651 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_id"))) TS_LDKEvent_PaymentPathFailed_get_payment_id(uint64_t ptr) {
2652 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2653 assert(obj->tag == LDKEvent_PaymentPathFailed);
2654 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2655 memcpy(payment_id_arr->elems, obj->payment_path_failed.payment_id.data, 32);
2656 return payment_id_arr;
2658 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_hash"))) TS_LDKEvent_PaymentPathFailed_get_payment_hash(uint64_t ptr) {
2659 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2660 assert(obj->tag == LDKEvent_PaymentPathFailed);
2661 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2662 memcpy(payment_hash_arr->elems, obj->payment_path_failed.payment_hash.data, 32);
2663 return payment_hash_arr;
2665 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently"))) TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(uint64_t ptr) {
2666 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2667 assert(obj->tag == LDKEvent_PaymentPathFailed);
2668 jboolean payment_failed_permanently_conv = obj->payment_path_failed.payment_failed_permanently;
2669 return payment_failed_permanently_conv;
2671 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_failure"))) TS_LDKEvent_PaymentPathFailed_get_failure(uint64_t ptr) {
2672 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2673 assert(obj->tag == LDKEvent_PaymentPathFailed);
2674 uint64_t failure_ref = tag_ptr(&obj->payment_path_failed.failure, false);
2677 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_path"))) TS_LDKEvent_PaymentPathFailed_get_path(uint64_t ptr) {
2678 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2679 assert(obj->tag == LDKEvent_PaymentPathFailed);
2680 LDKPath path_var = obj->payment_path_failed.path;
2681 uint64_t path_ref = 0;
2682 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2683 path_ref = tag_ptr(path_var.inner, false);
2686 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_short_channel_id"))) TS_LDKEvent_PaymentPathFailed_get_short_channel_id(uint64_t ptr) {
2687 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2688 assert(obj->tag == LDKEvent_PaymentPathFailed);
2689 uint64_t short_channel_id_ref = tag_ptr(&obj->payment_path_failed.short_channel_id, false);
2690 return short_channel_id_ref;
2692 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_id"))) TS_LDKEvent_ProbeSuccessful_get_payment_id(uint64_t ptr) {
2693 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2694 assert(obj->tag == LDKEvent_ProbeSuccessful);
2695 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2696 memcpy(payment_id_arr->elems, obj->probe_successful.payment_id.data, 32);
2697 return payment_id_arr;
2699 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_hash"))) TS_LDKEvent_ProbeSuccessful_get_payment_hash(uint64_t ptr) {
2700 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2701 assert(obj->tag == LDKEvent_ProbeSuccessful);
2702 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2703 memcpy(payment_hash_arr->elems, obj->probe_successful.payment_hash.data, 32);
2704 return payment_hash_arr;
2706 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_path"))) TS_LDKEvent_ProbeSuccessful_get_path(uint64_t ptr) {
2707 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2708 assert(obj->tag == LDKEvent_ProbeSuccessful);
2709 LDKPath path_var = obj->probe_successful.path;
2710 uint64_t path_ref = 0;
2711 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2712 path_ref = tag_ptr(path_var.inner, false);
2715 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_id"))) TS_LDKEvent_ProbeFailed_get_payment_id(uint64_t ptr) {
2716 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2717 assert(obj->tag == LDKEvent_ProbeFailed);
2718 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
2719 memcpy(payment_id_arr->elems, obj->probe_failed.payment_id.data, 32);
2720 return payment_id_arr;
2722 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_hash"))) TS_LDKEvent_ProbeFailed_get_payment_hash(uint64_t ptr) {
2723 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2724 assert(obj->tag == LDKEvent_ProbeFailed);
2725 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2726 memcpy(payment_hash_arr->elems, obj->probe_failed.payment_hash.data, 32);
2727 return payment_hash_arr;
2729 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_path"))) TS_LDKEvent_ProbeFailed_get_path(uint64_t ptr) {
2730 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2731 assert(obj->tag == LDKEvent_ProbeFailed);
2732 LDKPath path_var = obj->probe_failed.path;
2733 uint64_t path_ref = 0;
2734 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
2735 path_ref = tag_ptr(path_var.inner, false);
2738 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_short_channel_id"))) TS_LDKEvent_ProbeFailed_get_short_channel_id(uint64_t ptr) {
2739 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2740 assert(obj->tag == LDKEvent_ProbeFailed);
2741 uint64_t short_channel_id_ref = tag_ptr(&obj->probe_failed.short_channel_id, false);
2742 return short_channel_id_ref;
2744 int64_t __attribute__((export_name("TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable"))) TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(uint64_t ptr) {
2745 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2746 assert(obj->tag == LDKEvent_PendingHTLCsForwardable);
2747 int64_t time_forwardable_conv = obj->pending_htl_cs_forwardable.time_forwardable;
2748 return time_forwardable_conv;
2750 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_intercept_id"))) TS_LDKEvent_HTLCIntercepted_get_intercept_id(uint64_t ptr) {
2751 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2752 assert(obj->tag == LDKEvent_HTLCIntercepted);
2753 int8_tArray intercept_id_arr = init_int8_tArray(32, __LINE__);
2754 memcpy(intercept_id_arr->elems, obj->htlc_intercepted.intercept_id.data, 32);
2755 return intercept_id_arr;
2757 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid"))) TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(uint64_t ptr) {
2758 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2759 assert(obj->tag == LDKEvent_HTLCIntercepted);
2760 int64_t requested_next_hop_scid_conv = obj->htlc_intercepted.requested_next_hop_scid;
2761 return requested_next_hop_scid_conv;
2763 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_payment_hash"))) TS_LDKEvent_HTLCIntercepted_get_payment_hash(uint64_t ptr) {
2764 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2765 assert(obj->tag == LDKEvent_HTLCIntercepted);
2766 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
2767 memcpy(payment_hash_arr->elems, obj->htlc_intercepted.payment_hash.data, 32);
2768 return payment_hash_arr;
2770 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(uint64_t ptr) {
2771 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2772 assert(obj->tag == LDKEvent_HTLCIntercepted);
2773 int64_t inbound_amount_msat_conv = obj->htlc_intercepted.inbound_amount_msat;
2774 return inbound_amount_msat_conv;
2776 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(uint64_t ptr) {
2777 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2778 assert(obj->tag == LDKEvent_HTLCIntercepted);
2779 int64_t expected_outbound_amount_msat_conv = obj->htlc_intercepted.expected_outbound_amount_msat;
2780 return expected_outbound_amount_msat_conv;
2782 uint64_tArray __attribute__((export_name("TS_LDKEvent_SpendableOutputs_get_outputs"))) TS_LDKEvent_SpendableOutputs_get_outputs(uint64_t ptr) {
2783 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2784 assert(obj->tag == LDKEvent_SpendableOutputs);
2785 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
2786 uint64_tArray outputs_arr = NULL;
2787 outputs_arr = init_uint64_tArray(outputs_var.datalen, __LINE__);
2788 uint64_t *outputs_arr_ptr = (uint64_t*)(((uint8_t*)outputs_arr) + 8);
2789 for (size_t b = 0; b < outputs_var.datalen; b++) {
2790 uint64_t outputs_conv_27_ref = tag_ptr(&outputs_var.data[b], false);
2791 outputs_arr_ptr[b] = outputs_conv_27_ref;
2796 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_prev_channel_id"))) TS_LDKEvent_PaymentForwarded_get_prev_channel_id(uint64_t ptr) {
2797 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2798 assert(obj->tag == LDKEvent_PaymentForwarded);
2799 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
2800 memcpy(prev_channel_id_arr->elems, obj->payment_forwarded.prev_channel_id.data, 32);
2801 return prev_channel_id_arr;
2803 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_next_channel_id"))) TS_LDKEvent_PaymentForwarded_get_next_channel_id(uint64_t ptr) {
2804 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2805 assert(obj->tag == LDKEvent_PaymentForwarded);
2806 int8_tArray next_channel_id_arr = init_int8_tArray(32, __LINE__);
2807 memcpy(next_channel_id_arr->elems, obj->payment_forwarded.next_channel_id.data, 32);
2808 return next_channel_id_arr;
2810 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_fee_earned_msat"))) TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(uint64_t ptr) {
2811 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2812 assert(obj->tag == LDKEvent_PaymentForwarded);
2813 uint64_t fee_earned_msat_ref = tag_ptr(&obj->payment_forwarded.fee_earned_msat, false);
2814 return fee_earned_msat_ref;
2816 jboolean __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx"))) TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(uint64_t ptr) {
2817 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2818 assert(obj->tag == LDKEvent_PaymentForwarded);
2819 jboolean claim_from_onchain_tx_conv = obj->payment_forwarded.claim_from_onchain_tx;
2820 return claim_from_onchain_tx_conv;
2822 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat"))) TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(uint64_t ptr) {
2823 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2824 assert(obj->tag == LDKEvent_PaymentForwarded);
2825 uint64_t outbound_amount_forwarded_msat_ref = tag_ptr(&obj->payment_forwarded.outbound_amount_forwarded_msat, false);
2826 return outbound_amount_forwarded_msat_ref;
2828 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_channel_id"))) TS_LDKEvent_ChannelPending_get_channel_id(uint64_t ptr) {
2829 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2830 assert(obj->tag == LDKEvent_ChannelPending);
2831 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2832 memcpy(channel_id_arr->elems, obj->channel_pending.channel_id.data, 32);
2833 return channel_id_arr;
2835 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_user_channel_id"))) TS_LDKEvent_ChannelPending_get_user_channel_id(uint64_t ptr) {
2836 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2837 assert(obj->tag == LDKEvent_ChannelPending);
2838 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2839 memcpy(user_channel_id_arr->elems, obj->channel_pending.user_channel_id.le_bytes, 16);
2840 return user_channel_id_arr;
2842 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_former_temporary_channel_id"))) TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(uint64_t ptr) {
2843 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2844 assert(obj->tag == LDKEvent_ChannelPending);
2845 int8_tArray former_temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2846 memcpy(former_temporary_channel_id_arr->elems, obj->channel_pending.former_temporary_channel_id.data, 32);
2847 return former_temporary_channel_id_arr;
2849 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_counterparty_node_id"))) TS_LDKEvent_ChannelPending_get_counterparty_node_id(uint64_t ptr) {
2850 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2851 assert(obj->tag == LDKEvent_ChannelPending);
2852 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2853 memcpy(counterparty_node_id_arr->elems, obj->channel_pending.counterparty_node_id.compressed_form, 33);
2854 return counterparty_node_id_arr;
2856 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelPending_get_funding_txo"))) TS_LDKEvent_ChannelPending_get_funding_txo(uint64_t ptr) {
2857 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2858 assert(obj->tag == LDKEvent_ChannelPending);
2859 LDKOutPoint funding_txo_var = obj->channel_pending.funding_txo;
2860 uint64_t funding_txo_ref = 0;
2861 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
2862 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
2863 return funding_txo_ref;
2865 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_id"))) TS_LDKEvent_ChannelReady_get_channel_id(uint64_t ptr) {
2866 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2867 assert(obj->tag == LDKEvent_ChannelReady);
2868 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2869 memcpy(channel_id_arr->elems, obj->channel_ready.channel_id.data, 32);
2870 return channel_id_arr;
2872 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_user_channel_id"))) TS_LDKEvent_ChannelReady_get_user_channel_id(uint64_t ptr) {
2873 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2874 assert(obj->tag == LDKEvent_ChannelReady);
2875 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2876 memcpy(user_channel_id_arr->elems, obj->channel_ready.user_channel_id.le_bytes, 16);
2877 return user_channel_id_arr;
2879 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_counterparty_node_id"))) TS_LDKEvent_ChannelReady_get_counterparty_node_id(uint64_t ptr) {
2880 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2881 assert(obj->tag == LDKEvent_ChannelReady);
2882 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2883 memcpy(counterparty_node_id_arr->elems, obj->channel_ready.counterparty_node_id.compressed_form, 33);
2884 return counterparty_node_id_arr;
2886 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_type"))) TS_LDKEvent_ChannelReady_get_channel_type(uint64_t ptr) {
2887 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2888 assert(obj->tag == LDKEvent_ChannelReady);
2889 LDKChannelTypeFeatures channel_type_var = obj->channel_ready.channel_type;
2890 uint64_t channel_type_ref = 0;
2891 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2892 channel_type_ref = tag_ptr(channel_type_var.inner, false);
2893 return channel_type_ref;
2895 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_channel_id"))) TS_LDKEvent_ChannelClosed_get_channel_id(uint64_t ptr) {
2896 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2897 assert(obj->tag == LDKEvent_ChannelClosed);
2898 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2899 memcpy(channel_id_arr->elems, obj->channel_closed.channel_id.data, 32);
2900 return channel_id_arr;
2902 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_user_channel_id"))) TS_LDKEvent_ChannelClosed_get_user_channel_id(uint64_t ptr) {
2903 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2904 assert(obj->tag == LDKEvent_ChannelClosed);
2905 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
2906 memcpy(user_channel_id_arr->elems, obj->channel_closed.user_channel_id.le_bytes, 16);
2907 return user_channel_id_arr;
2909 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_reason"))) TS_LDKEvent_ChannelClosed_get_reason(uint64_t ptr) {
2910 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2911 assert(obj->tag == LDKEvent_ChannelClosed);
2912 uint64_t reason_ref = tag_ptr(&obj->channel_closed.reason, false);
2915 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_channel_id"))) TS_LDKEvent_DiscardFunding_get_channel_id(uint64_t ptr) {
2916 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2917 assert(obj->tag == LDKEvent_DiscardFunding);
2918 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2919 memcpy(channel_id_arr->elems, obj->discard_funding.channel_id.data, 32);
2920 return channel_id_arr;
2922 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_transaction"))) TS_LDKEvent_DiscardFunding_get_transaction(uint64_t ptr) {
2923 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2924 assert(obj->tag == LDKEvent_DiscardFunding);
2925 LDKTransaction transaction_var = obj->discard_funding.transaction;
2926 int8_tArray transaction_arr = init_int8_tArray(transaction_var.datalen, __LINE__);
2927 memcpy(transaction_arr->elems, transaction_var.data, transaction_var.datalen);
2928 return transaction_arr;
2930 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id"))) TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(uint64_t ptr) {
2931 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2932 assert(obj->tag == LDKEvent_OpenChannelRequest);
2933 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2934 memcpy(temporary_channel_id_arr->elems, obj->open_channel_request.temporary_channel_id.data, 32);
2935 return temporary_channel_id_arr;
2937 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id"))) TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(uint64_t ptr) {
2938 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2939 assert(obj->tag == LDKEvent_OpenChannelRequest);
2940 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2941 memcpy(counterparty_node_id_arr->elems, obj->open_channel_request.counterparty_node_id.compressed_form, 33);
2942 return counterparty_node_id_arr;
2944 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_funding_satoshis"))) TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(uint64_t ptr) {
2945 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2946 assert(obj->tag == LDKEvent_OpenChannelRequest);
2947 int64_t funding_satoshis_conv = obj->open_channel_request.funding_satoshis;
2948 return funding_satoshis_conv;
2950 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_push_msat"))) TS_LDKEvent_OpenChannelRequest_get_push_msat(uint64_t ptr) {
2951 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2952 assert(obj->tag == LDKEvent_OpenChannelRequest);
2953 int64_t push_msat_conv = obj->open_channel_request.push_msat;
2954 return push_msat_conv;
2956 uint64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_channel_type"))) TS_LDKEvent_OpenChannelRequest_get_channel_type(uint64_t ptr) {
2957 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2958 assert(obj->tag == LDKEvent_OpenChannelRequest);
2959 LDKChannelTypeFeatures channel_type_var = obj->open_channel_request.channel_type;
2960 uint64_t channel_type_ref = 0;
2961 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2962 channel_type_ref = tag_ptr(channel_type_var.inner, false);
2963 return channel_type_ref;
2965 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id"))) TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(uint64_t ptr) {
2966 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2967 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2968 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
2969 memcpy(prev_channel_id_arr->elems, obj->htlc_handling_failed.prev_channel_id.data, 32);
2970 return prev_channel_id_arr;
2972 uint64_t __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination"))) TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(uint64_t ptr) {
2973 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
2974 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2975 uint64_t failed_next_destination_ref = tag_ptr(&obj->htlc_handling_failed.failed_next_destination, false);
2976 return failed_next_destination_ref;
2978 uint32_t __attribute__((export_name("TS_LDKCOption_EventZ_ty_from_ptr"))) TS_LDKCOption_EventZ_ty_from_ptr(uint64_t ptr) {
2979 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
2981 case LDKCOption_EventZ_Some: return 0;
2982 case LDKCOption_EventZ_None: return 1;
2986 uint64_t __attribute__((export_name("TS_LDKCOption_EventZ_Some_get_some"))) TS_LDKCOption_EventZ_Some_get_some(uint64_t ptr) {
2987 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
2988 assert(obj->tag == LDKCOption_EventZ_Some);
2989 uint64_t some_ref = tag_ptr(&obj->some, false);
2992 static inline struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
2993 CHECK(owner->result_ok);
2994 return COption_EventZ_clone(&*owner->contents.result);
2996 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_ok"))) TS_CResult_COption_EventZDecodeErrorZ_get_ok(uint64_t owner) {
2997 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
2998 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
2999 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_ok(owner_conv);
3000 uint64_t ret_ref = tag_ptr(ret_copy, true);
3004 static inline struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
3005 CHECK(!owner->result_ok);
3006 return DecodeError_clone(&*owner->contents.err);
3008 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_err"))) TS_CResult_COption_EventZDecodeErrorZ_get_err(uint64_t owner) {
3009 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
3010 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3011 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_err(owner_conv);
3012 uint64_t ret_ref = tag_ptr(ret_copy, true);
3016 uint32_t __attribute__((export_name("TS_LDKErrorAction_ty_from_ptr"))) TS_LDKErrorAction_ty_from_ptr(uint64_t ptr) {
3017 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3019 case LDKErrorAction_DisconnectPeer: return 0;
3020 case LDKErrorAction_IgnoreError: return 1;
3021 case LDKErrorAction_IgnoreAndLog: return 2;
3022 case LDKErrorAction_IgnoreDuplicateGossip: return 3;
3023 case LDKErrorAction_SendErrorMessage: return 4;
3024 case LDKErrorAction_SendWarningMessage: return 5;
3028 uint64_t __attribute__((export_name("TS_LDKErrorAction_DisconnectPeer_get_msg"))) TS_LDKErrorAction_DisconnectPeer_get_msg(uint64_t ptr) {
3029 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3030 assert(obj->tag == LDKErrorAction_DisconnectPeer);
3031 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
3032 uint64_t msg_ref = 0;
3033 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3034 msg_ref = tag_ptr(msg_var.inner, false);
3037 uint32_t __attribute__((export_name("TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log"))) TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(uint64_t ptr) {
3038 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3039 assert(obj->tag == LDKErrorAction_IgnoreAndLog);
3040 uint32_t ignore_and_log_conv = LDKLevel_to_js(obj->ignore_and_log);
3041 return ignore_and_log_conv;
3043 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendErrorMessage_get_msg"))) TS_LDKErrorAction_SendErrorMessage_get_msg(uint64_t ptr) {
3044 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3045 assert(obj->tag == LDKErrorAction_SendErrorMessage);
3046 LDKErrorMessage msg_var = obj->send_error_message.msg;
3047 uint64_t msg_ref = 0;
3048 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3049 msg_ref = tag_ptr(msg_var.inner, false);
3052 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_msg"))) TS_LDKErrorAction_SendWarningMessage_get_msg(uint64_t ptr) {
3053 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3054 assert(obj->tag == LDKErrorAction_SendWarningMessage);
3055 LDKWarningMessage msg_var = obj->send_warning_message.msg;
3056 uint64_t msg_ref = 0;
3057 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3058 msg_ref = tag_ptr(msg_var.inner, false);
3061 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_log_level"))) TS_LDKErrorAction_SendWarningMessage_get_log_level(uint64_t ptr) {
3062 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3063 assert(obj->tag == LDKErrorAction_SendWarningMessage);
3064 uint32_t log_level_conv = LDKLevel_to_js(obj->send_warning_message.log_level);
3065 return log_level_conv;
3067 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_ty_from_ptr"))) TS_LDKMessageSendEvent_ty_from_ptr(uint64_t ptr) {
3068 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3070 case LDKMessageSendEvent_SendAcceptChannel: return 0;
3071 case LDKMessageSendEvent_SendOpenChannel: return 1;
3072 case LDKMessageSendEvent_SendFundingCreated: return 2;
3073 case LDKMessageSendEvent_SendFundingSigned: return 3;
3074 case LDKMessageSendEvent_SendChannelReady: return 4;
3075 case LDKMessageSendEvent_SendAnnouncementSignatures: return 5;
3076 case LDKMessageSendEvent_UpdateHTLCs: return 6;
3077 case LDKMessageSendEvent_SendRevokeAndACK: return 7;
3078 case LDKMessageSendEvent_SendClosingSigned: return 8;
3079 case LDKMessageSendEvent_SendShutdown: return 9;
3080 case LDKMessageSendEvent_SendChannelReestablish: return 10;
3081 case LDKMessageSendEvent_SendChannelAnnouncement: return 11;
3082 case LDKMessageSendEvent_BroadcastChannelAnnouncement: return 12;
3083 case LDKMessageSendEvent_BroadcastChannelUpdate: return 13;
3084 case LDKMessageSendEvent_BroadcastNodeAnnouncement: return 14;
3085 case LDKMessageSendEvent_SendChannelUpdate: return 15;
3086 case LDKMessageSendEvent_HandleError: return 16;
3087 case LDKMessageSendEvent_SendChannelRangeQuery: return 17;
3088 case LDKMessageSendEvent_SendShortIdsQuery: return 18;
3089 case LDKMessageSendEvent_SendReplyChannelRange: return 19;
3090 case LDKMessageSendEvent_SendGossipTimestampFilter: return 20;
3094 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(uint64_t ptr) {
3095 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3096 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
3097 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3098 memcpy(node_id_arr->elems, obj->send_accept_channel.node_id.compressed_form, 33);
3101 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_msg"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(uint64_t ptr) {
3102 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3103 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
3104 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
3105 uint64_t msg_ref = 0;
3106 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3107 msg_ref = tag_ptr(msg_var.inner, false);
3110 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_node_id"))) TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(uint64_t ptr) {
3111 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3112 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
3113 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3114 memcpy(node_id_arr->elems, obj->send_open_channel.node_id.compressed_form, 33);
3117 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_msg"))) TS_LDKMessageSendEvent_SendOpenChannel_get_msg(uint64_t ptr) {
3118 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3119 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
3120 LDKOpenChannel msg_var = obj->send_open_channel.msg;
3121 uint64_t msg_ref = 0;
3122 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3123 msg_ref = tag_ptr(msg_var.inner, false);
3126 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_node_id"))) TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(uint64_t ptr) {
3127 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3128 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
3129 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3130 memcpy(node_id_arr->elems, obj->send_funding_created.node_id.compressed_form, 33);
3133 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_msg"))) TS_LDKMessageSendEvent_SendFundingCreated_get_msg(uint64_t ptr) {
3134 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3135 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
3136 LDKFundingCreated msg_var = obj->send_funding_created.msg;
3137 uint64_t msg_ref = 0;
3138 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3139 msg_ref = tag_ptr(msg_var.inner, false);
3142 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(uint64_t ptr) {
3143 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3144 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
3145 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3146 memcpy(node_id_arr->elems, obj->send_funding_signed.node_id.compressed_form, 33);
3149 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_msg"))) TS_LDKMessageSendEvent_SendFundingSigned_get_msg(uint64_t ptr) {
3150 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3151 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
3152 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
3153 uint64_t msg_ref = 0;
3154 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3155 msg_ref = tag_ptr(msg_var.inner, false);
3158 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReady_get_node_id(uint64_t ptr) {
3159 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3160 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
3161 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3162 memcpy(node_id_arr->elems, obj->send_channel_ready.node_id.compressed_form, 33);
3165 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_msg"))) TS_LDKMessageSendEvent_SendChannelReady_get_msg(uint64_t ptr) {
3166 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3167 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
3168 LDKChannelReady msg_var = obj->send_channel_ready.msg;
3169 uint64_t msg_ref = 0;
3170 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3171 msg_ref = tag_ptr(msg_var.inner, false);
3174 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(uint64_t ptr) {
3175 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3176 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
3177 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3178 memcpy(node_id_arr->elems, obj->send_announcement_signatures.node_id.compressed_form, 33);
3181 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(uint64_t ptr) {
3182 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3183 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
3184 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
3185 uint64_t msg_ref = 0;
3186 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3187 msg_ref = tag_ptr(msg_var.inner, false);
3190 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(uint64_t ptr) {
3191 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3192 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
3193 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3194 memcpy(node_id_arr->elems, obj->update_htl_cs.node_id.compressed_form, 33);
3197 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_updates"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(uint64_t ptr) {
3198 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3199 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
3200 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
3201 uint64_t updates_ref = 0;
3202 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
3203 updates_ref = tag_ptr(updates_var.inner, false);
3206 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(uint64_t ptr) {
3207 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3208 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
3209 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3210 memcpy(node_id_arr->elems, obj->send_revoke_and_ack.node_id.compressed_form, 33);
3213 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(uint64_t ptr) {
3214 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3215 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
3216 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
3217 uint64_t msg_ref = 0;
3218 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3219 msg_ref = tag_ptr(msg_var.inner, false);
3222 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(uint64_t ptr) {
3223 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3224 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
3225 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3226 memcpy(node_id_arr->elems, obj->send_closing_signed.node_id.compressed_form, 33);
3229 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_msg"))) TS_LDKMessageSendEvent_SendClosingSigned_get_msg(uint64_t ptr) {
3230 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3231 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
3232 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
3233 uint64_t msg_ref = 0;
3234 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3235 msg_ref = tag_ptr(msg_var.inner, false);
3238 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_node_id"))) TS_LDKMessageSendEvent_SendShutdown_get_node_id(uint64_t ptr) {
3239 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3240 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
3241 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3242 memcpy(node_id_arr->elems, obj->send_shutdown.node_id.compressed_form, 33);
3245 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_msg"))) TS_LDKMessageSendEvent_SendShutdown_get_msg(uint64_t ptr) {
3246 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3247 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
3248 LDKShutdown msg_var = obj->send_shutdown.msg;
3249 uint64_t msg_ref = 0;
3250 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3251 msg_ref = tag_ptr(msg_var.inner, false);
3254 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(uint64_t ptr) {
3255 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3256 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
3257 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3258 memcpy(node_id_arr->elems, obj->send_channel_reestablish.node_id.compressed_form, 33);
3261 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_msg"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(uint64_t ptr) {
3262 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3263 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
3264 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
3265 uint64_t msg_ref = 0;
3266 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3267 msg_ref = tag_ptr(msg_var.inner, false);
3270 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(uint64_t ptr) {
3271 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3272 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3273 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3274 memcpy(node_id_arr->elems, obj->send_channel_announcement.node_id.compressed_form, 33);
3277 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(uint64_t ptr) {
3278 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3279 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3280 LDKChannelAnnouncement msg_var = obj->send_channel_announcement.msg;
3281 uint64_t msg_ref = 0;
3282 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3283 msg_ref = tag_ptr(msg_var.inner, false);
3286 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(uint64_t ptr) {
3287 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3288 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3289 LDKChannelUpdate update_msg_var = obj->send_channel_announcement.update_msg;
3290 uint64_t update_msg_ref = 0;
3291 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
3292 update_msg_ref = tag_ptr(update_msg_var.inner, false);
3293 return update_msg_ref;
3295 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(uint64_t ptr) {
3296 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3297 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
3298 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
3299 uint64_t msg_ref = 0;
3300 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3301 msg_ref = tag_ptr(msg_var.inner, false);
3304 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(uint64_t ptr) {
3305 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3306 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
3307 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
3308 uint64_t update_msg_ref = 0;
3309 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
3310 update_msg_ref = tag_ptr(update_msg_var.inner, false);
3311 return update_msg_ref;
3313 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(uint64_t ptr) {
3314 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3315 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelUpdate);
3316 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
3317 uint64_t msg_ref = 0;
3318 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3319 msg_ref = tag_ptr(msg_var.inner, false);
3322 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(uint64_t ptr) {
3323 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3324 assert(obj->tag == LDKMessageSendEvent_BroadcastNodeAnnouncement);
3325 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
3326 uint64_t msg_ref = 0;
3327 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3328 msg_ref = tag_ptr(msg_var.inner, false);
3331 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(uint64_t ptr) {
3332 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3333 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
3334 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3335 memcpy(node_id_arr->elems, obj->send_channel_update.node_id.compressed_form, 33);
3338 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(uint64_t ptr) {
3339 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3340 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
3341 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
3342 uint64_t msg_ref = 0;
3343 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3344 msg_ref = tag_ptr(msg_var.inner, false);
3347 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_node_id"))) TS_LDKMessageSendEvent_HandleError_get_node_id(uint64_t ptr) {
3348 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3349 assert(obj->tag == LDKMessageSendEvent_HandleError);
3350 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3351 memcpy(node_id_arr->elems, obj->handle_error.node_id.compressed_form, 33);
3354 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_action"))) TS_LDKMessageSendEvent_HandleError_get_action(uint64_t ptr) {
3355 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3356 assert(obj->tag == LDKMessageSendEvent_HandleError);
3357 uint64_t action_ref = tag_ptr(&obj->handle_error.action, false);
3360 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(uint64_t ptr) {
3361 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3362 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
3363 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3364 memcpy(node_id_arr->elems, obj->send_channel_range_query.node_id.compressed_form, 33);
3367 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(uint64_t ptr) {
3368 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3369 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
3370 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
3371 uint64_t msg_ref = 0;
3372 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3373 msg_ref = tag_ptr(msg_var.inner, false);
3376 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(uint64_t ptr) {
3377 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3378 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
3379 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3380 memcpy(node_id_arr->elems, obj->send_short_ids_query.node_id.compressed_form, 33);
3383 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(uint64_t ptr) {
3384 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3385 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
3386 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
3387 uint64_t msg_ref = 0;
3388 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3389 msg_ref = tag_ptr(msg_var.inner, false);
3392 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(uint64_t ptr) {
3393 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3394 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
3395 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3396 memcpy(node_id_arr->elems, obj->send_reply_channel_range.node_id.compressed_form, 33);
3399 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(uint64_t ptr) {
3400 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3401 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
3402 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
3403 uint64_t msg_ref = 0;
3404 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3405 msg_ref = tag_ptr(msg_var.inner, false);
3408 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(uint64_t ptr) {
3409 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3410 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
3411 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3412 memcpy(node_id_arr->elems, obj->send_gossip_timestamp_filter.node_id.compressed_form, 33);
3415 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(uint64_t ptr) {
3416 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3417 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
3418 LDKGossipTimestampFilter msg_var = obj->send_gossip_timestamp_filter.msg;
3419 uint64_t msg_ref = 0;
3420 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3421 msg_ref = tag_ptr(msg_var.inner, false);
3424 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
3425 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
3426 for (size_t i = 0; i < ret.datalen; i++) {
3427 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
3431 static inline LDKCVec_ChainHashZ CVec_ChainHashZ_clone(const LDKCVec_ChainHashZ *orig) {
3432 LDKCVec_ChainHashZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ChainHashZ clone bytes"), .datalen = orig->datalen };
3433 for (size_t i = 0; i < ret.datalen; i++) {
3434 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
3438 static inline struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
3439 CHECK(owner->result_ok);
3440 return *owner->contents.result;
3442 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_ok"))) TS_CResult_PublicKeyErrorZ_get_ok(uint64_t owner) {
3443 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(owner);
3444 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
3445 memcpy(ret_arr->elems, CResult_PublicKeyErrorZ_get_ok(owner_conv).compressed_form, 33);
3449 static inline enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
3450 CHECK(!owner->result_ok);
3451 return *owner->contents.err;
3453 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_err"))) TS_CResult_PublicKeyErrorZ_get_err(uint64_t owner) {
3454 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(owner);
3455 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PublicKeyErrorZ_get_err(owner_conv));
3459 static inline struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3460 LDKNodeId ret = *owner->contents.result;
3461 ret.is_owned = false;
3464 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_ok"))) TS_CResult_NodeIdDecodeErrorZ_get_ok(uint64_t owner) {
3465 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3466 LDKNodeId ret_var = CResult_NodeIdDecodeErrorZ_get_ok(owner_conv);
3467 uint64_t ret_ref = 0;
3468 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3469 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3473 static inline struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3474 CHECK(!owner->result_ok);
3475 return DecodeError_clone(&*owner->contents.err);
3477 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_err"))) TS_CResult_NodeIdDecodeErrorZ_get_err(uint64_t owner) {
3478 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3479 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3480 *ret_copy = CResult_NodeIdDecodeErrorZ_get_err(owner_conv);
3481 uint64_t ret_ref = tag_ptr(ret_copy, true);
3485 static inline struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3486 CHECK(owner->result_ok);
3487 return COption_NetworkUpdateZ_clone(&*owner->contents.result);
3489 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint64_t owner) {
3490 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3491 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
3492 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner_conv);
3493 uint64_t ret_ref = tag_ptr(ret_copy, true);
3497 static inline struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3498 CHECK(!owner->result_ok);
3499 return DecodeError_clone(&*owner->contents.err);
3501 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint64_t owner) {
3502 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3503 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3504 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner_conv);
3505 uint64_t ret_ref = tag_ptr(ret_copy, true);
3509 static inline struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner){
3510 CHECK(owner->result_ok);
3511 return TxOut_clone(&*owner->contents.result);
3513 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_get_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_get_ok(uint64_t owner) {
3514 LDKCResult_TxOutUtxoLookupErrorZ* owner_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(owner);
3515 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
3516 *ret_ref = CResult_TxOutUtxoLookupErrorZ_get_ok(owner_conv);
3517 return tag_ptr(ret_ref, true);
3520 static inline enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner){
3521 CHECK(!owner->result_ok);
3522 return UtxoLookupError_clone(&*owner->contents.err);
3524 uint32_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_get_err"))) TS_CResult_TxOutUtxoLookupErrorZ_get_err(uint64_t owner) {
3525 LDKCResult_TxOutUtxoLookupErrorZ* owner_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(owner);
3526 uint32_t ret_conv = LDKUtxoLookupError_to_js(CResult_TxOutUtxoLookupErrorZ_get_err(owner_conv));
3530 uint32_t __attribute__((export_name("TS_LDKUtxoResult_ty_from_ptr"))) TS_LDKUtxoResult_ty_from_ptr(uint64_t ptr) {
3531 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3533 case LDKUtxoResult_Sync: return 0;
3534 case LDKUtxoResult_Async: return 1;
3538 uint64_t __attribute__((export_name("TS_LDKUtxoResult_Sync_get_sync"))) TS_LDKUtxoResult_Sync_get_sync(uint64_t ptr) {
3539 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3540 assert(obj->tag == LDKUtxoResult_Sync);
3541 LDKCResult_TxOutUtxoLookupErrorZ* sync_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
3542 *sync_conv = obj->sync;
3543 *sync_conv = CResult_TxOutUtxoLookupErrorZ_clone(sync_conv);
3544 return tag_ptr(sync_conv, true);
3546 uint64_t __attribute__((export_name("TS_LDKUtxoResult_Async_get_async"))) TS_LDKUtxoResult_Async_get_async(uint64_t ptr) {
3547 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3548 assert(obj->tag == LDKUtxoResult_Async);
3549 LDKUtxoFuture async_var = obj->async;
3550 uint64_t async_ref = 0;
3551 CHECK_INNER_FIELD_ACCESS_OR_NULL(async_var);
3552 async_ref = tag_ptr(async_var.inner, false);
3555 typedef struct LDKUtxoLookup_JCalls {
3556 atomic_size_t refcnt;
3557 uint32_t instance_ptr;
3558 } LDKUtxoLookup_JCalls;
3559 static void LDKUtxoLookup_JCalls_free(void* this_arg) {
3560 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) this_arg;
3561 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3565 LDKUtxoResult get_utxo_LDKUtxoLookup_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
3566 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) this_arg;
3567 int8_tArray genesis_hash_arr = init_int8_tArray(32, __LINE__);
3568 memcpy(genesis_hash_arr->elems, *genesis_hash, 32);
3569 int64_t short_channel_id_conv = short_channel_id;
3570 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);
3571 void* ret_ptr = untag_ptr(ret);
3572 CHECK_ACCESS(ret_ptr);
3573 LDKUtxoResult ret_conv = *(LDKUtxoResult*)(ret_ptr);
3574 FREE(untag_ptr(ret));
3577 static void LDKUtxoLookup_JCalls_cloned(LDKUtxoLookup* new_obj) {
3578 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) new_obj->this_arg;
3579 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3581 static inline LDKUtxoLookup LDKUtxoLookup_init (JSValue o) {
3582 LDKUtxoLookup_JCalls *calls = MALLOC(sizeof(LDKUtxoLookup_JCalls), "LDKUtxoLookup_JCalls");
3583 atomic_init(&calls->refcnt, 1);
3584 calls->instance_ptr = o;
3586 LDKUtxoLookup ret = {
3587 .this_arg = (void*) calls,
3588 .get_utxo = get_utxo_LDKUtxoLookup_jcall,
3589 .free = LDKUtxoLookup_JCalls_free,
3593 uint64_t __attribute__((export_name("TS_LDKUtxoLookup_new"))) TS_LDKUtxoLookup_new(JSValue o) {
3594 LDKUtxoLookup *res_ptr = MALLOC(sizeof(LDKUtxoLookup), "LDKUtxoLookup");
3595 *res_ptr = LDKUtxoLookup_init(o);
3596 return tag_ptr(res_ptr, true);
3598 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) {
3599 void* this_arg_ptr = untag_ptr(this_arg);
3600 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
3601 LDKUtxoLookup* this_arg_conv = (LDKUtxoLookup*)this_arg_ptr;
3602 uint8_t genesis_hash_arr[32];
3603 CHECK(genesis_hash->arr_len == 32);
3604 memcpy(genesis_hash_arr, genesis_hash->elems, 32); FREE(genesis_hash);
3605 uint8_t (*genesis_hash_ref)[32] = &genesis_hash_arr;
3606 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
3607 *ret_copy = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
3608 uint64_t ret_ref = tag_ptr(ret_copy, true);
3612 uint32_t __attribute__((export_name("TS_LDKCOption_UtxoLookupZ_ty_from_ptr"))) TS_LDKCOption_UtxoLookupZ_ty_from_ptr(uint64_t ptr) {
3613 LDKCOption_UtxoLookupZ *obj = (LDKCOption_UtxoLookupZ*)untag_ptr(ptr);
3615 case LDKCOption_UtxoLookupZ_Some: return 0;
3616 case LDKCOption_UtxoLookupZ_None: return 1;
3620 uint64_t __attribute__((export_name("TS_LDKCOption_UtxoLookupZ_Some_get_some"))) TS_LDKCOption_UtxoLookupZ_Some_get_some(uint64_t ptr) {
3621 LDKCOption_UtxoLookupZ *obj = (LDKCOption_UtxoLookupZ*)untag_ptr(ptr);
3622 assert(obj->tag == LDKCOption_UtxoLookupZ_Some);
3623 LDKUtxoLookup* some_ret = MALLOC(sizeof(LDKUtxoLookup), "LDKUtxoLookup");
3624 *some_ret = obj->some;
3625 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
3626 if ((*some_ret).free == LDKUtxoLookup_JCalls_free) {
3627 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
3628 LDKUtxoLookup_JCalls_cloned(&(*some_ret));
3630 return tag_ptr(some_ret, true);
3632 static inline bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3633 CHECK(owner->result_ok);
3634 return *owner->contents.result;
3636 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_ok"))) TS_CResult_boolLightningErrorZ_get_ok(uint64_t owner) {
3637 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3638 jboolean ret_conv = CResult_boolLightningErrorZ_get_ok(owner_conv);
3642 static inline struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3643 LDKLightningError ret = *owner->contents.err;
3644 ret.is_owned = false;
3647 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_err"))) TS_CResult_boolLightningErrorZ_get_err(uint64_t owner) {
3648 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3649 LDKLightningError ret_var = CResult_boolLightningErrorZ_get_err(owner_conv);
3650 uint64_t ret_ref = 0;
3651 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3652 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3656 static inline struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3657 LDKChannelAnnouncement ret = owner->a;
3658 ret.is_owned = false;
3661 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint64_t owner) {
3662 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3663 LDKChannelAnnouncement ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner_conv);
3664 uint64_t ret_ref = 0;
3665 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3666 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3670 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3671 LDKChannelUpdate ret = owner->b;
3672 ret.is_owned = false;
3675 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint64_t owner) {
3676 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3677 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner_conv);
3678 uint64_t ret_ref = 0;
3679 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3680 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3684 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3685 LDKChannelUpdate ret = owner->c;
3686 ret.is_owned = false;
3689 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint64_t owner) {
3690 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3691 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner_conv);
3692 uint64_t ret_ref = 0;
3693 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3694 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3698 uint32_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(uint64_t ptr) {
3699 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3701 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some: return 0;
3702 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None: return 1;
3706 uint64_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(uint64_t ptr) {
3707 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3708 assert(obj->tag == LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some);
3709 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* some_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
3710 *some_conv = obj->some;
3711 *some_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(some_conv);
3712 return tag_ptr(some_conv, true);
3714 static inline void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3715 CHECK(owner->result_ok);
3716 return *owner->contents.result;
3718 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_ok"))) TS_CResult_NoneLightningErrorZ_get_ok(uint64_t owner) {
3719 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3720 CResult_NoneLightningErrorZ_get_ok(owner_conv);
3723 static inline struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3724 LDKLightningError ret = *owner->contents.err;
3725 ret.is_owned = false;
3728 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_err"))) TS_CResult_NoneLightningErrorZ_get_err(uint64_t owner) {
3729 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3730 LDKLightningError ret_var = CResult_NoneLightningErrorZ_get_err(owner_conv);
3731 uint64_t ret_ref = 0;
3732 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3733 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3737 static inline struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3738 LDKChannelUpdateInfo ret = *owner->contents.result;
3739 ret.is_owned = false;
3742 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(uint64_t owner) {
3743 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
3744 LDKChannelUpdateInfo ret_var = CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner_conv);
3745 uint64_t ret_ref = 0;
3746 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3747 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3751 static inline struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3752 CHECK(!owner->result_ok);
3753 return DecodeError_clone(&*owner->contents.err);
3755 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(uint64_t owner) {
3756 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
3757 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3758 *ret_copy = CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner_conv);
3759 uint64_t ret_ref = tag_ptr(ret_copy, true);
3763 static inline struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3764 LDKChannelInfo ret = *owner->contents.result;
3765 ret.is_owned = false;
3768 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_get_ok(uint64_t owner) {
3769 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
3770 LDKChannelInfo ret_var = CResult_ChannelInfoDecodeErrorZ_get_ok(owner_conv);
3771 uint64_t ret_ref = 0;
3772 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3773 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3777 static inline struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3778 CHECK(!owner->result_ok);
3779 return DecodeError_clone(&*owner->contents.err);
3781 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelInfoDecodeErrorZ_get_err(uint64_t owner) {
3782 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
3783 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3784 *ret_copy = CResult_ChannelInfoDecodeErrorZ_get_err(owner_conv);
3785 uint64_t ret_ref = tag_ptr(ret_copy, true);
3789 static inline struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3790 LDKRoutingFees ret = *owner->contents.result;
3791 ret.is_owned = false;
3794 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_get_ok(uint64_t owner) {
3795 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
3796 LDKRoutingFees ret_var = CResult_RoutingFeesDecodeErrorZ_get_ok(owner_conv);
3797 uint64_t ret_ref = 0;
3798 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3799 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3803 static inline struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3804 CHECK(!owner->result_ok);
3805 return DecodeError_clone(&*owner->contents.err);
3807 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_err"))) TS_CResult_RoutingFeesDecodeErrorZ_get_err(uint64_t owner) {
3808 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
3809 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3810 *ret_copy = CResult_RoutingFeesDecodeErrorZ_get_err(owner_conv);
3811 uint64_t ret_ref = tag_ptr(ret_copy, true);
3815 uint32_t __attribute__((export_name("TS_LDKNetAddress_ty_from_ptr"))) TS_LDKNetAddress_ty_from_ptr(uint64_t ptr) {
3816 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3818 case LDKNetAddress_IPv4: return 0;
3819 case LDKNetAddress_IPv6: return 1;
3820 case LDKNetAddress_OnionV2: return 2;
3821 case LDKNetAddress_OnionV3: return 3;
3822 case LDKNetAddress_Hostname: return 4;
3826 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv4_get_addr"))) TS_LDKNetAddress_IPv4_get_addr(uint64_t ptr) {
3827 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3828 assert(obj->tag == LDKNetAddress_IPv4);
3829 int8_tArray addr_arr = init_int8_tArray(4, __LINE__);
3830 memcpy(addr_arr->elems, obj->i_pv4.addr.data, 4);
3833 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv4_get_port"))) TS_LDKNetAddress_IPv4_get_port(uint64_t ptr) {
3834 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3835 assert(obj->tag == LDKNetAddress_IPv4);
3836 int16_t port_conv = obj->i_pv4.port;
3839 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv6_get_addr"))) TS_LDKNetAddress_IPv6_get_addr(uint64_t ptr) {
3840 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3841 assert(obj->tag == LDKNetAddress_IPv6);
3842 int8_tArray addr_arr = init_int8_tArray(16, __LINE__);
3843 memcpy(addr_arr->elems, obj->i_pv6.addr.data, 16);
3846 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv6_get_port"))) TS_LDKNetAddress_IPv6_get_port(uint64_t ptr) {
3847 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3848 assert(obj->tag == LDKNetAddress_IPv6);
3849 int16_t port_conv = obj->i_pv6.port;
3852 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV2_get_onion_v2"))) TS_LDKNetAddress_OnionV2_get_onion_v2(uint64_t ptr) {
3853 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3854 assert(obj->tag == LDKNetAddress_OnionV2);
3855 int8_tArray onion_v2_arr = init_int8_tArray(12, __LINE__);
3856 memcpy(onion_v2_arr->elems, obj->onion_v2.data, 12);
3857 return onion_v2_arr;
3859 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_ed25519_pubkey"))) TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(uint64_t ptr) {
3860 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3861 assert(obj->tag == LDKNetAddress_OnionV3);
3862 int8_tArray ed25519_pubkey_arr = init_int8_tArray(32, __LINE__);
3863 memcpy(ed25519_pubkey_arr->elems, obj->onion_v3.ed25519_pubkey.data, 32);
3864 return ed25519_pubkey_arr;
3866 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_checksum"))) TS_LDKNetAddress_OnionV3_get_checksum(uint64_t ptr) {
3867 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3868 assert(obj->tag == LDKNetAddress_OnionV3);
3869 int16_t checksum_conv = obj->onion_v3.checksum;
3870 return checksum_conv;
3872 int8_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_version"))) TS_LDKNetAddress_OnionV3_get_version(uint64_t ptr) {
3873 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3874 assert(obj->tag == LDKNetAddress_OnionV3);
3875 int8_t version_conv = obj->onion_v3.version;
3876 return version_conv;
3878 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_port"))) TS_LDKNetAddress_OnionV3_get_port(uint64_t ptr) {
3879 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3880 assert(obj->tag == LDKNetAddress_OnionV3);
3881 int16_t port_conv = obj->onion_v3.port;
3884 uint64_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_hostname"))) TS_LDKNetAddress_Hostname_get_hostname(uint64_t ptr) {
3885 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3886 assert(obj->tag == LDKNetAddress_Hostname);
3887 LDKHostname hostname_var = obj->hostname.hostname;
3888 uint64_t hostname_ref = 0;
3889 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_var);
3890 hostname_ref = tag_ptr(hostname_var.inner, false);
3891 return hostname_ref;
3893 int16_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_port"))) TS_LDKNetAddress_Hostname_get_port(uint64_t ptr) {
3894 LDKNetAddress *obj = (LDKNetAddress*)untag_ptr(ptr);
3895 assert(obj->tag == LDKNetAddress_Hostname);
3896 int16_t port_conv = obj->hostname.port;
3899 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
3900 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
3901 for (size_t i = 0; i < ret.datalen; i++) {
3902 ret.data[i] = NetAddress_clone(&orig->data[i]);
3906 static inline struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3907 LDKNodeAnnouncementInfo ret = *owner->contents.result;
3908 ret.is_owned = false;
3911 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint64_t owner) {
3912 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
3913 LDKNodeAnnouncementInfo ret_var = CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner_conv);
3914 uint64_t ret_ref = 0;
3915 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3916 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3920 static inline struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3921 CHECK(!owner->result_ok);
3922 return DecodeError_clone(&*owner->contents.err);
3924 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(uint64_t owner) {
3925 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
3926 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3927 *ret_copy = CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner_conv);
3928 uint64_t ret_ref = tag_ptr(ret_copy, true);
3932 static inline struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3933 LDKNodeAlias ret = *owner->contents.result;
3934 ret.is_owned = false;
3937 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_ok"))) TS_CResult_NodeAliasDecodeErrorZ_get_ok(uint64_t owner) {
3938 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
3939 LDKNodeAlias ret_var = CResult_NodeAliasDecodeErrorZ_get_ok(owner_conv);
3940 uint64_t ret_ref = 0;
3941 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3942 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3946 static inline struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3947 CHECK(!owner->result_ok);
3948 return DecodeError_clone(&*owner->contents.err);
3950 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_err"))) TS_CResult_NodeAliasDecodeErrorZ_get_err(uint64_t owner) {
3951 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
3952 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3953 *ret_copy = CResult_NodeAliasDecodeErrorZ_get_err(owner_conv);
3954 uint64_t ret_ref = tag_ptr(ret_copy, true);
3958 static inline struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3959 LDKNodeInfo ret = *owner->contents.result;
3960 ret.is_owned = false;
3963 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeInfoDecodeErrorZ_get_ok(uint64_t owner) {
3964 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
3965 LDKNodeInfo ret_var = CResult_NodeInfoDecodeErrorZ_get_ok(owner_conv);
3966 uint64_t ret_ref = 0;
3967 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3968 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3972 static inline struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3973 CHECK(!owner->result_ok);
3974 return DecodeError_clone(&*owner->contents.err);
3976 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_err"))) TS_CResult_NodeInfoDecodeErrorZ_get_err(uint64_t owner) {
3977 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
3978 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3979 *ret_copy = CResult_NodeInfoDecodeErrorZ_get_err(owner_conv);
3980 uint64_t ret_ref = tag_ptr(ret_copy, true);
3984 static inline struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3985 LDKNetworkGraph ret = *owner->contents.result;
3986 ret.is_owned = false;
3989 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_get_ok(uint64_t owner) {
3990 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
3991 LDKNetworkGraph ret_var = CResult_NetworkGraphDecodeErrorZ_get_ok(owner_conv);
3992 uint64_t ret_ref = 0;
3993 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3994 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3998 static inline struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3999 CHECK(!owner->result_ok);
4000 return DecodeError_clone(&*owner->contents.err);
4002 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_err"))) TS_CResult_NetworkGraphDecodeErrorZ_get_err(uint64_t owner) {
4003 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
4004 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4005 *ret_copy = CResult_NetworkGraphDecodeErrorZ_get_err(owner_conv);
4006 uint64_t ret_ref = tag_ptr(ret_copy, true);
4010 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr"))) TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(uint64_t ptr) {
4011 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(ptr);
4013 case LDKCOption_CVec_NetAddressZZ_Some: return 0;
4014 case LDKCOption_CVec_NetAddressZZ_None: return 1;
4018 uint64_tArray __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_Some_get_some"))) TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(uint64_t ptr) {
4019 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(ptr);
4020 assert(obj->tag == LDKCOption_CVec_NetAddressZZ_Some);
4021 LDKCVec_NetAddressZ some_var = obj->some;
4022 uint64_tArray some_arr = NULL;
4023 some_arr = init_uint64_tArray(some_var.datalen, __LINE__);
4024 uint64_t *some_arr_ptr = (uint64_t*)(((uint8_t*)some_arr) + 8);
4025 for (size_t m = 0; m < some_var.datalen; m++) {
4026 uint64_t some_conv_12_ref = tag_ptr(&some_var.data[m], false);
4027 some_arr_ptr[m] = some_conv_12_ref;
4032 static inline struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4033 LDKDelayedPaymentOutputDescriptor ret = *owner->contents.result;
4034 ret.is_owned = false;
4037 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4038 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4039 LDKDelayedPaymentOutputDescriptor ret_var = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
4040 uint64_t ret_ref = 0;
4041 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4042 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4046 static inline struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4047 CHECK(!owner->result_ok);
4048 return DecodeError_clone(&*owner->contents.err);
4050 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4051 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4052 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4053 *ret_copy = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
4054 uint64_t ret_ref = tag_ptr(ret_copy, true);
4058 static inline struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4059 LDKStaticPaymentOutputDescriptor ret = *owner->contents.result;
4060 ret.is_owned = false;
4063 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4064 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4065 LDKStaticPaymentOutputDescriptor ret_var = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
4066 uint64_t ret_ref = 0;
4067 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4068 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4072 static inline struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4073 CHECK(!owner->result_ok);
4074 return DecodeError_clone(&*owner->contents.err);
4076 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4077 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4078 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4079 *ret_copy = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
4080 uint64_t ret_ref = tag_ptr(ret_copy, true);
4084 static inline struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4085 CHECK(owner->result_ok);
4086 return SpendableOutputDescriptor_clone(&*owner->contents.result);
4088 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4089 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4090 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
4091 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
4092 uint64_t ret_ref = tag_ptr(ret_copy, true);
4096 static inline struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
4097 CHECK(!owner->result_ok);
4098 return DecodeError_clone(&*owner->contents.err);
4100 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4101 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
4102 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4103 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner_conv);
4104 uint64_t ret_ref = tag_ptr(ret_copy, true);
4108 static inline LDKCVec_PaymentPreimageZ CVec_PaymentPreimageZ_clone(const LDKCVec_PaymentPreimageZ *orig) {
4109 LDKCVec_PaymentPreimageZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_PaymentPreimageZ clone bytes"), .datalen = orig->datalen };
4110 for (size_t i = 0; i < ret.datalen; i++) {
4111 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
4115 static inline struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
4118 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_a"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(uint64_t owner) {
4119 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(owner);
4120 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
4121 memcpy(ret_arr->elems, C2Tuple_SignatureCVec_SignatureZZ_get_a(owner_conv).compact_form, 64);
4125 static inline struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
4128 ptrArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_b"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(uint64_t owner) {
4129 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(owner);
4130 LDKCVec_SignatureZ ret_var = C2Tuple_SignatureCVec_SignatureZZ_get_b(owner_conv);
4131 ptrArray ret_arr = NULL;
4132 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
4133 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
4134 for (size_t m = 0; m < ret_var.datalen; m++) {
4135 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
4136 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
4137 ret_arr_ptr[m] = ret_conv_12_arr;
4143 static inline struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
4144 CHECK(owner->result_ok);
4145 return C2Tuple_SignatureCVec_SignatureZZ_clone(&*owner->contents.result);
4147 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint64_t owner) {
4148 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(owner);
4149 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
4150 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner_conv);
4151 return tag_ptr(ret_conv, true);
4154 static inline void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
4155 CHECK(!owner->result_ok);
4156 return *owner->contents.err;
4158 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(uint64_t owner) {
4159 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(owner);
4160 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner_conv);
4163 static inline struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
4164 CHECK(owner->result_ok);
4165 return *owner->contents.result;
4167 int8_tArray __attribute__((export_name("TS_CResult_SignatureNoneZ_get_ok"))) TS_CResult_SignatureNoneZ_get_ok(uint64_t owner) {
4168 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(owner);
4169 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
4170 memcpy(ret_arr->elems, CResult_SignatureNoneZ_get_ok(owner_conv).compact_form, 64);
4174 static inline void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
4175 CHECK(!owner->result_ok);
4176 return *owner->contents.err;
4178 void __attribute__((export_name("TS_CResult_SignatureNoneZ_get_err"))) TS_CResult_SignatureNoneZ_get_err(uint64_t owner) {
4179 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(owner);
4180 CResult_SignatureNoneZ_get_err(owner_conv);
4183 static inline struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
4184 CHECK(owner->result_ok);
4185 return *owner->contents.result;
4187 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_ok"))) TS_CResult_PublicKeyNoneZ_get_ok(uint64_t owner) {
4188 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
4189 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4190 memcpy(ret_arr->elems, CResult_PublicKeyNoneZ_get_ok(owner_conv).compressed_form, 33);
4194 static inline void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
4195 CHECK(!owner->result_ok);
4196 return *owner->contents.err;
4198 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_err"))) TS_CResult_PublicKeyNoneZ_get_err(uint64_t owner) {
4199 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
4200 CResult_PublicKeyNoneZ_get_err(owner_conv);
4203 uint32_t __attribute__((export_name("TS_LDKCOption_ScalarZ_ty_from_ptr"))) TS_LDKCOption_ScalarZ_ty_from_ptr(uint64_t ptr) {
4204 LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
4206 case LDKCOption_ScalarZ_Some: return 0;
4207 case LDKCOption_ScalarZ_None: return 1;
4211 uint64_t __attribute__((export_name("TS_LDKCOption_ScalarZ_Some_get_some"))) TS_LDKCOption_ScalarZ_Some_get_some(uint64_t ptr) {
4212 LDKCOption_ScalarZ *obj = (LDKCOption_ScalarZ*)untag_ptr(ptr);
4213 assert(obj->tag == LDKCOption_ScalarZ_Some);
4214 LDKBigEndianScalar* some_ref = &obj->some;
4215 return tag_ptr(some_ref, false);
4217 static inline struct LDKThirtyTwoBytes CResult_SharedSecretNoneZ_get_ok(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
4218 CHECK(owner->result_ok);
4219 return ThirtyTwoBytes_clone(&*owner->contents.result);
4221 int8_tArray __attribute__((export_name("TS_CResult_SharedSecretNoneZ_get_ok"))) TS_CResult_SharedSecretNoneZ_get_ok(uint64_t owner) {
4222 LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
4223 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4224 memcpy(ret_arr->elems, CResult_SharedSecretNoneZ_get_ok(owner_conv).data, 32);
4228 static inline void CResult_SharedSecretNoneZ_get_err(LDKCResult_SharedSecretNoneZ *NONNULL_PTR owner){
4229 CHECK(!owner->result_ok);
4230 return *owner->contents.err;
4232 void __attribute__((export_name("TS_CResult_SharedSecretNoneZ_get_err"))) TS_CResult_SharedSecretNoneZ_get_err(uint64_t owner) {
4233 LDKCResult_SharedSecretNoneZ* owner_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(owner);
4234 CResult_SharedSecretNoneZ_get_err(owner_conv);
4237 static inline struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4238 CHECK(owner->result_ok);
4239 return *owner->contents.result;
4241 int8_tArray __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_ok"))) TS_CResult_RecoverableSignatureNoneZ_get_ok(uint64_t owner) {
4242 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
4243 int8_tArray ret_arr = init_int8_tArray(68, __LINE__);
4244 memcpy(ret_arr->elems, CResult_RecoverableSignatureNoneZ_get_ok(owner_conv).serialized_form, 68);
4248 static inline void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4249 CHECK(!owner->result_ok);
4250 return *owner->contents.err;
4252 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_err"))) TS_CResult_RecoverableSignatureNoneZ_get_err(uint64_t owner) {
4253 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
4254 CResult_RecoverableSignatureNoneZ_get_err(owner_conv);
4257 typedef struct LDKChannelSigner_JCalls {
4258 atomic_size_t refcnt;
4259 uint32_t instance_ptr;
4260 } LDKChannelSigner_JCalls;
4261 static void LDKChannelSigner_JCalls_free(void* this_arg) {
4262 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4263 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4267 LDKPublicKey get_per_commitment_point_LDKChannelSigner_jcall(const void* this_arg, uint64_t idx) {
4268 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4269 int64_t idx_conv = idx;
4270 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 2, idx_conv, 0, 0, 0, 0, 0);
4271 LDKPublicKey ret_ref;
4272 CHECK(ret->arr_len == 33);
4273 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
4276 LDKThirtyTwoBytes release_commitment_secret_LDKChannelSigner_jcall(const void* this_arg, uint64_t idx) {
4277 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4278 int64_t idx_conv = idx;
4279 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 3, idx_conv, 0, 0, 0, 0, 0);
4280 LDKThirtyTwoBytes ret_ref;
4281 CHECK(ret->arr_len == 32);
4282 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
4285 LDKCResult_NoneNoneZ validate_holder_commitment_LDKChannelSigner_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * holder_tx, LDKCVec_PaymentPreimageZ preimages) {
4286 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4287 LDKHolderCommitmentTransaction holder_tx_var = *holder_tx;
4288 uint64_t holder_tx_ref = 0;
4289 holder_tx_var = HolderCommitmentTransaction_clone(&holder_tx_var);
4290 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
4291 holder_tx_ref = tag_ptr(holder_tx_var.inner, holder_tx_var.is_owned);
4292 LDKCVec_PaymentPreimageZ preimages_var = preimages;
4293 ptrArray preimages_arr = NULL;
4294 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
4295 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
4296 for (size_t m = 0; m < preimages_var.datalen; m++) {
4297 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
4298 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
4299 preimages_arr_ptr[m] = preimages_conv_12_arr;
4302 FREE(preimages_var.data);
4303 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 4, holder_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
4304 void* ret_ptr = untag_ptr(ret);
4305 CHECK_ACCESS(ret_ptr);
4306 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
4307 FREE(untag_ptr(ret));
4310 LDKThirtyTwoBytes channel_keys_id_LDKChannelSigner_jcall(const void* this_arg) {
4311 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4312 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 5, 0, 0, 0, 0, 0, 0);
4313 LDKThirtyTwoBytes ret_ref;
4314 CHECK(ret->arr_len == 32);
4315 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
4318 void provide_channel_parameters_LDKChannelSigner_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
4319 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
4320 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
4321 uint64_t channel_parameters_ref = 0;
4322 channel_parameters_var = ChannelTransactionParameters_clone(&channel_parameters_var);
4323 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
4324 channel_parameters_ref = tag_ptr(channel_parameters_var.inner, channel_parameters_var.is_owned);
4325 js_invoke_function_buuuuu(j_calls->instance_ptr, 6, channel_parameters_ref, 0, 0, 0, 0, 0);
4327 static void LDKChannelSigner_JCalls_cloned(LDKChannelSigner* new_obj) {
4328 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) new_obj->this_arg;
4329 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4331 static inline LDKChannelSigner LDKChannelSigner_init (JSValue o, uint64_t pubkeys) {
4332 LDKChannelSigner_JCalls *calls = MALLOC(sizeof(LDKChannelSigner_JCalls), "LDKChannelSigner_JCalls");
4333 atomic_init(&calls->refcnt, 1);
4334 calls->instance_ptr = o;
4336 LDKChannelPublicKeys pubkeys_conv;
4337 pubkeys_conv.inner = untag_ptr(pubkeys);
4338 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4339 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4341 LDKChannelSigner ret = {
4342 .this_arg = (void*) calls,
4343 .get_per_commitment_point = get_per_commitment_point_LDKChannelSigner_jcall,
4344 .release_commitment_secret = release_commitment_secret_LDKChannelSigner_jcall,
4345 .validate_holder_commitment = validate_holder_commitment_LDKChannelSigner_jcall,
4346 .channel_keys_id = channel_keys_id_LDKChannelSigner_jcall,
4347 .provide_channel_parameters = provide_channel_parameters_LDKChannelSigner_jcall,
4348 .free = LDKChannelSigner_JCalls_free,
4349 .pubkeys = pubkeys_conv,
4350 .set_pubkeys = NULL,
4354 uint64_t __attribute__((export_name("TS_LDKChannelSigner_new"))) TS_LDKChannelSigner_new(JSValue o, uint64_t pubkeys) {
4355 LDKChannelSigner *res_ptr = MALLOC(sizeof(LDKChannelSigner), "LDKChannelSigner");
4356 *res_ptr = LDKChannelSigner_init(o, pubkeys);
4357 return tag_ptr(res_ptr, true);
4359 int8_tArray __attribute__((export_name("TS_ChannelSigner_get_per_commitment_point"))) TS_ChannelSigner_get_per_commitment_point(uint64_t this_arg, int64_t idx) {
4360 void* this_arg_ptr = untag_ptr(this_arg);
4361 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4362 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4363 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4364 memcpy(ret_arr->elems, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form, 33);
4368 int8_tArray __attribute__((export_name("TS_ChannelSigner_release_commitment_secret"))) TS_ChannelSigner_release_commitment_secret(uint64_t this_arg, int64_t idx) {
4369 void* this_arg_ptr = untag_ptr(this_arg);
4370 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4371 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4372 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4373 memcpy(ret_arr->elems, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data, 32);
4377 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) {
4378 void* this_arg_ptr = untag_ptr(this_arg);
4379 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4380 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4381 LDKHolderCommitmentTransaction holder_tx_conv;
4382 holder_tx_conv.inner = untag_ptr(holder_tx);
4383 holder_tx_conv.is_owned = ptr_is_owned(holder_tx);
4384 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
4385 holder_tx_conv.is_owned = false;
4386 LDKCVec_PaymentPreimageZ preimages_constr;
4387 preimages_constr.datalen = preimages->arr_len;
4388 if (preimages_constr.datalen > 0)
4389 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4391 preimages_constr.data = NULL;
4392 int8_tArray* preimages_vals = (void*) preimages->elems;
4393 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4394 int8_tArray preimages_conv_12 = preimages_vals[m];
4395 LDKThirtyTwoBytes preimages_conv_12_ref;
4396 CHECK(preimages_conv_12->arr_len == 32);
4397 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4398 preimages_constr.data[m] = preimages_conv_12_ref;
4401 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4402 *ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv, preimages_constr);
4403 return tag_ptr(ret_conv, true);
4406 int8_tArray __attribute__((export_name("TS_ChannelSigner_channel_keys_id"))) TS_ChannelSigner_channel_keys_id(uint64_t this_arg) {
4407 void* this_arg_ptr = untag_ptr(this_arg);
4408 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4409 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4410 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4411 memcpy(ret_arr->elems, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data, 32);
4415 void __attribute__((export_name("TS_ChannelSigner_provide_channel_parameters"))) TS_ChannelSigner_provide_channel_parameters(uint64_t this_arg, uint64_t channel_parameters) {
4416 void* this_arg_ptr = untag_ptr(this_arg);
4417 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4418 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4419 LDKChannelTransactionParameters channel_parameters_conv;
4420 channel_parameters_conv.inner = untag_ptr(channel_parameters);
4421 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
4422 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
4423 channel_parameters_conv.is_owned = false;
4424 (this_arg_conv->provide_channel_parameters)(this_arg_conv->this_arg, &channel_parameters_conv);
4427 LDKChannelPublicKeys LDKChannelSigner_set_get_pubkeys(LDKChannelSigner* this_arg) {
4428 if (this_arg->set_pubkeys != NULL)
4429 this_arg->set_pubkeys(this_arg);
4430 return this_arg->pubkeys;
4432 uint64_t __attribute__((export_name("TS_ChannelSigner_get_pubkeys"))) TS_ChannelSigner_get_pubkeys(uint64_t this_arg) {
4433 void* this_arg_ptr = untag_ptr(this_arg);
4434 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4435 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
4436 LDKChannelPublicKeys ret_var = LDKChannelSigner_set_get_pubkeys(this_arg_conv);
4437 uint64_t ret_ref = 0;
4438 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4439 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4443 typedef struct LDKEcdsaChannelSigner_JCalls {
4444 atomic_size_t refcnt;
4445 uint32_t instance_ptr;
4446 LDKChannelSigner_JCalls* ChannelSigner;
4447 } LDKEcdsaChannelSigner_JCalls;
4448 static void LDKEcdsaChannelSigner_JCalls_free(void* this_arg) {
4449 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4450 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4454 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx, LDKCVec_PaymentPreimageZ preimages) {
4455 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4456 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
4457 uint64_t commitment_tx_ref = 0;
4458 commitment_tx_var = CommitmentTransaction_clone(&commitment_tx_var);
4459 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
4460 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
4461 LDKCVec_PaymentPreimageZ preimages_var = preimages;
4462 ptrArray preimages_arr = NULL;
4463 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
4464 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
4465 for (size_t m = 0; m < preimages_var.datalen; m++) {
4466 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
4467 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
4468 preimages_arr_ptr[m] = preimages_conv_12_arr;
4471 FREE(preimages_var.data);
4472 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 7, commitment_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
4473 void* ret_ptr = untag_ptr(ret);
4474 CHECK_ACCESS(ret_ptr);
4475 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
4476 FREE(untag_ptr(ret));
4479 LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKEcdsaChannelSigner_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
4480 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4481 int64_t idx_conv = idx;
4482 int8_tArray secret_arr = init_int8_tArray(32, __LINE__);
4483 memcpy(secret_arr->elems, *secret, 32);
4484 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 8, idx_conv, (uint32_t)secret_arr, 0, 0, 0, 0);
4485 void* ret_ptr = untag_ptr(ret);
4486 CHECK_ACCESS(ret_ptr);
4487 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
4488 FREE(untag_ptr(ret));
4491 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
4492 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4493 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
4494 uint64_t commitment_tx_ref = 0;
4495 commitment_tx_var = HolderCommitmentTransaction_clone(&commitment_tx_var);
4496 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
4497 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
4498 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 9, commitment_tx_ref, 0, 0, 0, 0, 0);
4499 void* ret_ptr = untag_ptr(ret);
4500 CHECK_ACCESS(ret_ptr);
4501 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
4502 FREE(untag_ptr(ret));
4505 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]) {
4506 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4507 LDKTransaction justice_tx_var = justice_tx;
4508 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
4509 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
4510 Transaction_free(justice_tx_var);
4511 uint32_t input_conv = input;
4512 int64_t amount_conv = amount;
4513 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
4514 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
4515 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);
4516 void* ret_ptr = untag_ptr(ret);
4517 CHECK_ACCESS(ret_ptr);
4518 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4519 FREE(untag_ptr(ret));
4522 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) {
4523 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4524 LDKTransaction justice_tx_var = justice_tx;
4525 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
4526 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
4527 Transaction_free(justice_tx_var);
4528 uint32_t input_conv = input;
4529 int64_t amount_conv = amount;
4530 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
4531 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
4532 LDKHTLCOutputInCommitment htlc_var = *htlc;
4533 uint64_t htlc_ref = 0;
4534 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4535 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4536 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
4537 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);
4538 void* ret_ptr = untag_ptr(ret);
4539 CHECK_ACCESS(ret_ptr);
4540 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4541 FREE(untag_ptr(ret));
4544 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) {
4545 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4546 LDKTransaction htlc_tx_var = htlc_tx;
4547 int8_tArray htlc_tx_arr = init_int8_tArray(htlc_tx_var.datalen, __LINE__);
4548 memcpy(htlc_tx_arr->elems, htlc_tx_var.data, htlc_tx_var.datalen);
4549 Transaction_free(htlc_tx_var);
4550 uint32_t input_conv = input;
4551 int64_t amount_conv = amount;
4552 int8_tArray per_commitment_point_arr = init_int8_tArray(33, __LINE__);
4553 memcpy(per_commitment_point_arr->elems, per_commitment_point.compressed_form, 33);
4554 LDKHTLCOutputInCommitment htlc_var = *htlc;
4555 uint64_t htlc_ref = 0;
4556 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4557 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4558 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
4559 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);
4560 void* ret_ptr = untag_ptr(ret);
4561 CHECK_ACCESS(ret_ptr);
4562 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4563 FREE(untag_ptr(ret));
4566 LDKCResult_SignatureNoneZ sign_closing_transaction_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
4567 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4568 LDKClosingTransaction closing_tx_var = *closing_tx;
4569 uint64_t closing_tx_ref = 0;
4570 closing_tx_var = ClosingTransaction_clone(&closing_tx_var);
4571 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
4572 closing_tx_ref = tag_ptr(closing_tx_var.inner, closing_tx_var.is_owned);
4573 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 13, closing_tx_ref, 0, 0, 0, 0, 0);
4574 void* ret_ptr = untag_ptr(ret);
4575 CHECK_ACCESS(ret_ptr);
4576 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4577 FREE(untag_ptr(ret));
4580 LDKCResult_SignatureNoneZ sign_holder_anchor_input_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction anchor_tx, uintptr_t input) {
4581 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4582 LDKTransaction anchor_tx_var = anchor_tx;
4583 int8_tArray anchor_tx_arr = init_int8_tArray(anchor_tx_var.datalen, __LINE__);
4584 memcpy(anchor_tx_arr->elems, anchor_tx_var.data, anchor_tx_var.datalen);
4585 Transaction_free(anchor_tx_var);
4586 uint32_t input_conv = input;
4587 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 14, (uint32_t)anchor_tx_arr, input_conv, 0, 0, 0, 0);
4588 void* ret_ptr = untag_ptr(ret);
4589 CHECK_ACCESS(ret_ptr);
4590 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4591 FREE(untag_ptr(ret));
4594 LDKCResult_SignatureNoneZ sign_channel_announcement_with_funding_key_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
4595 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
4596 LDKUnsignedChannelAnnouncement msg_var = *msg;
4597 uint64_t msg_ref = 0;
4598 msg_var = UnsignedChannelAnnouncement_clone(&msg_var);
4599 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4600 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
4601 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 15, msg_ref, 0, 0, 0, 0, 0);
4602 void* ret_ptr = untag_ptr(ret);
4603 CHECK_ACCESS(ret_ptr);
4604 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4605 FREE(untag_ptr(ret));
4608 static void LDKEcdsaChannelSigner_JCalls_cloned(LDKEcdsaChannelSigner* new_obj) {
4609 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) new_obj->this_arg;
4610 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4611 atomic_fetch_add_explicit(&j_calls->ChannelSigner->refcnt, 1, memory_order_release);
4613 static inline LDKEcdsaChannelSigner LDKEcdsaChannelSigner_init (JSValue o, JSValue ChannelSigner, uint64_t pubkeys) {
4614 LDKEcdsaChannelSigner_JCalls *calls = MALLOC(sizeof(LDKEcdsaChannelSigner_JCalls), "LDKEcdsaChannelSigner_JCalls");
4615 atomic_init(&calls->refcnt, 1);
4616 calls->instance_ptr = o;
4618 LDKChannelPublicKeys pubkeys_conv;
4619 pubkeys_conv.inner = untag_ptr(pubkeys);
4620 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4621 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4623 LDKEcdsaChannelSigner ret = {
4624 .this_arg = (void*) calls,
4625 .sign_counterparty_commitment = sign_counterparty_commitment_LDKEcdsaChannelSigner_jcall,
4626 .validate_counterparty_revocation = validate_counterparty_revocation_LDKEcdsaChannelSigner_jcall,
4627 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKEcdsaChannelSigner_jcall,
4628 .sign_justice_revoked_output = sign_justice_revoked_output_LDKEcdsaChannelSigner_jcall,
4629 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKEcdsaChannelSigner_jcall,
4630 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKEcdsaChannelSigner_jcall,
4631 .sign_closing_transaction = sign_closing_transaction_LDKEcdsaChannelSigner_jcall,
4632 .sign_holder_anchor_input = sign_holder_anchor_input_LDKEcdsaChannelSigner_jcall,
4633 .sign_channel_announcement_with_funding_key = sign_channel_announcement_with_funding_key_LDKEcdsaChannelSigner_jcall,
4634 .free = LDKEcdsaChannelSigner_JCalls_free,
4635 .ChannelSigner = LDKChannelSigner_init(ChannelSigner, pubkeys),
4637 calls->ChannelSigner = ret.ChannelSigner.this_arg;
4640 uint64_t __attribute__((export_name("TS_LDKEcdsaChannelSigner_new"))) TS_LDKEcdsaChannelSigner_new(JSValue o, JSValue ChannelSigner, uint64_t pubkeys) {
4641 LDKEcdsaChannelSigner *res_ptr = MALLOC(sizeof(LDKEcdsaChannelSigner), "LDKEcdsaChannelSigner");
4642 *res_ptr = LDKEcdsaChannelSigner_init(o, ChannelSigner, pubkeys);
4643 return tag_ptr(res_ptr, true);
4645 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) {
4646 void* this_arg_ptr = untag_ptr(this_arg);
4647 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4648 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4649 LDKCommitmentTransaction commitment_tx_conv;
4650 commitment_tx_conv.inner = untag_ptr(commitment_tx);
4651 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
4652 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4653 commitment_tx_conv.is_owned = false;
4654 LDKCVec_PaymentPreimageZ preimages_constr;
4655 preimages_constr.datalen = preimages->arr_len;
4656 if (preimages_constr.datalen > 0)
4657 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4659 preimages_constr.data = NULL;
4660 int8_tArray* preimages_vals = (void*) preimages->elems;
4661 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4662 int8_tArray preimages_conv_12 = preimages_vals[m];
4663 LDKThirtyTwoBytes preimages_conv_12_ref;
4664 CHECK(preimages_conv_12->arr_len == 32);
4665 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4666 preimages_constr.data[m] = preimages_conv_12_ref;
4669 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4670 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv, preimages_constr);
4671 return tag_ptr(ret_conv, true);
4674 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) {
4675 void* this_arg_ptr = untag_ptr(this_arg);
4676 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4677 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4678 uint8_t secret_arr[32];
4679 CHECK(secret->arr_len == 32);
4680 memcpy(secret_arr, secret->elems, 32); FREE(secret);
4681 uint8_t (*secret_ref)[32] = &secret_arr;
4682 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4683 *ret_conv = (this_arg_conv->validate_counterparty_revocation)(this_arg_conv->this_arg, idx, secret_ref);
4684 return tag_ptr(ret_conv, true);
4687 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) {
4688 void* this_arg_ptr = untag_ptr(this_arg);
4689 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4690 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4691 LDKHolderCommitmentTransaction commitment_tx_conv;
4692 commitment_tx_conv.inner = untag_ptr(commitment_tx);
4693 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
4694 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4695 commitment_tx_conv.is_owned = false;
4696 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4697 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
4698 return tag_ptr(ret_conv, true);
4701 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) {
4702 void* this_arg_ptr = untag_ptr(this_arg);
4703 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4704 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4705 LDKTransaction justice_tx_ref;
4706 justice_tx_ref.datalen = justice_tx->arr_len;
4707 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4708 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4709 justice_tx_ref.data_is_owned = true;
4710 uint8_t per_commitment_key_arr[32];
4711 CHECK(per_commitment_key->arr_len == 32);
4712 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4713 uint8_t (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4714 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4715 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
4716 return tag_ptr(ret_conv, true);
4719 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) {
4720 void* this_arg_ptr = untag_ptr(this_arg);
4721 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4722 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4723 LDKTransaction justice_tx_ref;
4724 justice_tx_ref.datalen = justice_tx->arr_len;
4725 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4726 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4727 justice_tx_ref.data_is_owned = true;
4728 uint8_t per_commitment_key_arr[32];
4729 CHECK(per_commitment_key->arr_len == 32);
4730 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4731 uint8_t (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4732 LDKHTLCOutputInCommitment htlc_conv;
4733 htlc_conv.inner = untag_ptr(htlc);
4734 htlc_conv.is_owned = ptr_is_owned(htlc);
4735 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4736 htlc_conv.is_owned = false;
4737 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4738 *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);
4739 return tag_ptr(ret_conv, true);
4742 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) {
4743 void* this_arg_ptr = untag_ptr(this_arg);
4744 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4745 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4746 LDKTransaction htlc_tx_ref;
4747 htlc_tx_ref.datalen = htlc_tx->arr_len;
4748 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
4749 memcpy(htlc_tx_ref.data, htlc_tx->elems, htlc_tx_ref.datalen); FREE(htlc_tx);
4750 htlc_tx_ref.data_is_owned = true;
4751 LDKPublicKey per_commitment_point_ref;
4752 CHECK(per_commitment_point->arr_len == 33);
4753 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
4754 LDKHTLCOutputInCommitment htlc_conv;
4755 htlc_conv.inner = untag_ptr(htlc);
4756 htlc_conv.is_owned = ptr_is_owned(htlc);
4757 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4758 htlc_conv.is_owned = false;
4759 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4760 *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);
4761 return tag_ptr(ret_conv, true);
4764 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_closing_transaction"))) TS_EcdsaChannelSigner_sign_closing_transaction(uint64_t this_arg, uint64_t closing_tx) {
4765 void* this_arg_ptr = untag_ptr(this_arg);
4766 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4767 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4768 LDKClosingTransaction closing_tx_conv;
4769 closing_tx_conv.inner = untag_ptr(closing_tx);
4770 closing_tx_conv.is_owned = ptr_is_owned(closing_tx);
4771 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
4772 closing_tx_conv.is_owned = false;
4773 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4774 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
4775 return tag_ptr(ret_conv, true);
4778 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) {
4779 void* this_arg_ptr = untag_ptr(this_arg);
4780 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4781 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4782 LDKTransaction anchor_tx_ref;
4783 anchor_tx_ref.datalen = anchor_tx->arr_len;
4784 anchor_tx_ref.data = MALLOC(anchor_tx_ref.datalen, "LDKTransaction Bytes");
4785 memcpy(anchor_tx_ref.data, anchor_tx->elems, anchor_tx_ref.datalen); FREE(anchor_tx);
4786 anchor_tx_ref.data_is_owned = true;
4787 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4788 *ret_conv = (this_arg_conv->sign_holder_anchor_input)(this_arg_conv->this_arg, anchor_tx_ref, input);
4789 return tag_ptr(ret_conv, true);
4792 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) {
4793 void* this_arg_ptr = untag_ptr(this_arg);
4794 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4795 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
4796 LDKUnsignedChannelAnnouncement msg_conv;
4797 msg_conv.inner = untag_ptr(msg);
4798 msg_conv.is_owned = ptr_is_owned(msg);
4799 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
4800 msg_conv.is_owned = false;
4801 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4802 *ret_conv = (this_arg_conv->sign_channel_announcement_with_funding_key)(this_arg_conv->this_arg, &msg_conv);
4803 return tag_ptr(ret_conv, true);
4806 typedef struct LDKWriteableEcdsaChannelSigner_JCalls {
4807 atomic_size_t refcnt;
4808 uint32_t instance_ptr;
4809 LDKEcdsaChannelSigner_JCalls* EcdsaChannelSigner;
4810 LDKChannelSigner_JCalls* ChannelSigner;
4811 } LDKWriteableEcdsaChannelSigner_JCalls;
4812 static void LDKWriteableEcdsaChannelSigner_JCalls_free(void* this_arg) {
4813 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) this_arg;
4814 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4818 LDKCVec_u8Z write_LDKWriteableEcdsaChannelSigner_jcall(const void* this_arg) {
4819 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) this_arg;
4820 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 16, 0, 0, 0, 0, 0, 0);
4821 LDKCVec_u8Z ret_ref;
4822 ret_ref.datalen = ret->arr_len;
4823 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
4824 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
4827 static void LDKWriteableEcdsaChannelSigner_JCalls_cloned(LDKWriteableEcdsaChannelSigner* new_obj) {
4828 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) new_obj->this_arg;
4829 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4830 atomic_fetch_add_explicit(&j_calls->EcdsaChannelSigner->refcnt, 1, memory_order_release);
4831 atomic_fetch_add_explicit(&j_calls->EcdsaChannelSigner->ChannelSigner->refcnt, 1, memory_order_release);
4833 static inline LDKWriteableEcdsaChannelSigner LDKWriteableEcdsaChannelSigner_init (JSValue o, JSValue EcdsaChannelSigner, JSValue ChannelSigner, uint64_t pubkeys) {
4834 LDKWriteableEcdsaChannelSigner_JCalls *calls = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner_JCalls), "LDKWriteableEcdsaChannelSigner_JCalls");
4835 atomic_init(&calls->refcnt, 1);
4836 calls->instance_ptr = o;
4838 LDKChannelPublicKeys pubkeys_conv;
4839 pubkeys_conv.inner = untag_ptr(pubkeys);
4840 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
4841 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4843 LDKWriteableEcdsaChannelSigner ret = {
4844 .this_arg = (void*) calls,
4845 .write = write_LDKWriteableEcdsaChannelSigner_jcall,
4846 .cloned = LDKWriteableEcdsaChannelSigner_JCalls_cloned,
4847 .free = LDKWriteableEcdsaChannelSigner_JCalls_free,
4848 .EcdsaChannelSigner = LDKEcdsaChannelSigner_init(EcdsaChannelSigner, ChannelSigner, pubkeys),
4850 calls->EcdsaChannelSigner = ret.EcdsaChannelSigner.this_arg;
4851 calls->ChannelSigner = ret.EcdsaChannelSigner.ChannelSigner.this_arg;
4854 uint64_t __attribute__((export_name("TS_LDKWriteableEcdsaChannelSigner_new"))) TS_LDKWriteableEcdsaChannelSigner_new(JSValue o, JSValue EcdsaChannelSigner, JSValue ChannelSigner, uint64_t pubkeys) {
4855 LDKWriteableEcdsaChannelSigner *res_ptr = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
4856 *res_ptr = LDKWriteableEcdsaChannelSigner_init(o, EcdsaChannelSigner, ChannelSigner, pubkeys);
4857 return tag_ptr(res_ptr, true);
4859 int8_tArray __attribute__((export_name("TS_WriteableEcdsaChannelSigner_write"))) TS_WriteableEcdsaChannelSigner_write(uint64_t this_arg) {
4860 void* this_arg_ptr = untag_ptr(this_arg);
4861 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
4862 LDKWriteableEcdsaChannelSigner* this_arg_conv = (LDKWriteableEcdsaChannelSigner*)this_arg_ptr;
4863 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
4864 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4865 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4866 CVec_u8Z_free(ret_var);
4870 static inline struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner){
4871 CHECK(owner->result_ok);
4872 return WriteableEcdsaChannelSigner_clone(&*owner->contents.result);
4874 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(uint64_t owner) {
4875 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* owner_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(owner);
4876 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
4877 *ret_ret = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner_conv);
4878 return tag_ptr(ret_ret, true);
4881 static inline struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner){
4882 CHECK(!owner->result_ok);
4883 return DecodeError_clone(&*owner->contents.err);
4885 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(uint64_t owner) {
4886 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* owner_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(owner);
4887 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4888 *ret_copy = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner_conv);
4889 uint64_t ret_ref = tag_ptr(ret_copy, true);
4893 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
4894 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
4895 for (size_t i = 0; i < ret.datalen; i++) {
4896 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
4900 static inline struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4901 CHECK(owner->result_ok);
4902 return CVec_CVec_u8ZZ_clone(&*owner->contents.result);
4904 ptrArray __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(uint64_t owner) {
4905 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
4906 LDKCVec_CVec_u8ZZ ret_var = CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner_conv);
4907 ptrArray ret_arr = NULL;
4908 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
4909 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
4910 for (size_t m = 0; m < ret_var.datalen; m++) {
4911 LDKCVec_u8Z ret_conv_12_var = ret_var.data[m];
4912 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
4913 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
4914 CVec_u8Z_free(ret_conv_12_var);
4915 ret_arr_ptr[m] = ret_conv_12_arr;
4922 static inline void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4923 CHECK(!owner->result_ok);
4924 return *owner->contents.err;
4926 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(uint64_t owner) {
4927 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
4928 CResult_CVec_CVec_u8ZZNoneZ_get_err(owner_conv);
4931 static inline struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4932 LDKInMemorySigner ret = *owner->contents.result;
4933 ret.is_owned = false;
4936 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_get_ok(uint64_t owner) {
4937 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
4938 LDKInMemorySigner ret_var = CResult_InMemorySignerDecodeErrorZ_get_ok(owner_conv);
4939 uint64_t ret_ref = 0;
4940 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4941 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4945 static inline struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4946 CHECK(!owner->result_ok);
4947 return DecodeError_clone(&*owner->contents.err);
4949 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_err"))) TS_CResult_InMemorySignerDecodeErrorZ_get_err(uint64_t owner) {
4950 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
4951 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4952 *ret_copy = CResult_InMemorySignerDecodeErrorZ_get_err(owner_conv);
4953 uint64_t ret_ref = tag_ptr(ret_copy, true);
4957 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
4958 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
4959 for (size_t i = 0; i < ret.datalen; i++) {
4960 ret.data[i] = TxOut_clone(&orig->data[i]);
4964 static inline struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4965 CHECK(owner->result_ok);
4966 return *owner->contents.result;
4968 int8_tArray __attribute__((export_name("TS_CResult_TransactionNoneZ_get_ok"))) TS_CResult_TransactionNoneZ_get_ok(uint64_t owner) {
4969 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
4970 LDKTransaction ret_var = CResult_TransactionNoneZ_get_ok(owner_conv);
4971 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4972 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4976 static inline void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4977 CHECK(!owner->result_ok);
4978 return *owner->contents.err;
4980 void __attribute__((export_name("TS_CResult_TransactionNoneZ_get_err"))) TS_CResult_TransactionNoneZ_get_err(uint64_t owner) {
4981 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
4982 CResult_TransactionNoneZ_get_err(owner_conv);
4985 uint32_t __attribute__((export_name("TS_LDKCOption_u16Z_ty_from_ptr"))) TS_LDKCOption_u16Z_ty_from_ptr(uint64_t ptr) {
4986 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
4988 case LDKCOption_u16Z_Some: return 0;
4989 case LDKCOption_u16Z_None: return 1;
4993 int16_t __attribute__((export_name("TS_LDKCOption_u16Z_Some_get_some"))) TS_LDKCOption_u16Z_Some_get_some(uint64_t ptr) {
4994 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
4995 assert(obj->tag == LDKCOption_u16Z_Some);
4996 int16_t some_conv = obj->some;
4999 static inline struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
5000 CHECK(owner->result_ok);
5001 return ThirtyTwoBytes_clone(&*owner->contents.result);
5003 int8_tArray __attribute__((export_name("TS_CResult__u832APIErrorZ_get_ok"))) TS_CResult__u832APIErrorZ_get_ok(uint64_t owner) {
5004 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(owner);
5005 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5006 memcpy(ret_arr->elems, CResult__u832APIErrorZ_get_ok(owner_conv).data, 32);
5010 static inline struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
5011 CHECK(!owner->result_ok);
5012 return APIError_clone(&*owner->contents.err);
5014 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_get_err"))) TS_CResult__u832APIErrorZ_get_err(uint64_t owner) {
5015 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(owner);
5016 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5017 *ret_copy = CResult__u832APIErrorZ_get_err(owner_conv);
5018 uint64_t ret_ref = tag_ptr(ret_copy, true);
5022 uint32_t __attribute__((export_name("TS_LDKRecentPaymentDetails_ty_from_ptr"))) TS_LDKRecentPaymentDetails_ty_from_ptr(uint64_t ptr) {
5023 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5025 case LDKRecentPaymentDetails_Pending: return 0;
5026 case LDKRecentPaymentDetails_Fulfilled: return 1;
5027 case LDKRecentPaymentDetails_Abandoned: return 2;
5031 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_payment_hash"))) TS_LDKRecentPaymentDetails_Pending_get_payment_hash(uint64_t ptr) {
5032 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5033 assert(obj->tag == LDKRecentPaymentDetails_Pending);
5034 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
5035 memcpy(payment_hash_arr->elems, obj->pending.payment_hash.data, 32);
5036 return payment_hash_arr;
5038 int64_t __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_total_msat"))) TS_LDKRecentPaymentDetails_Pending_get_total_msat(uint64_t ptr) {
5039 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5040 assert(obj->tag == LDKRecentPaymentDetails_Pending);
5041 int64_t total_msat_conv = obj->pending.total_msat;
5042 return total_msat_conv;
5044 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash"))) TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(uint64_t ptr) {
5045 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5046 assert(obj->tag == LDKRecentPaymentDetails_Fulfilled);
5047 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
5048 memcpy(payment_hash_arr->elems, obj->fulfilled.payment_hash.data, 32);
5049 return payment_hash_arr;
5051 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash"))) TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(uint64_t ptr) {
5052 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
5053 assert(obj->tag == LDKRecentPaymentDetails_Abandoned);
5054 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
5055 memcpy(payment_hash_arr->elems, obj->abandoned.payment_hash.data, 32);
5056 return payment_hash_arr;
5058 static inline LDKCVec_RecentPaymentDetailsZ CVec_RecentPaymentDetailsZ_clone(const LDKCVec_RecentPaymentDetailsZ *orig) {
5059 LDKCVec_RecentPaymentDetailsZ ret = { .data = MALLOC(sizeof(LDKRecentPaymentDetails) * orig->datalen, "LDKCVec_RecentPaymentDetailsZ clone bytes"), .datalen = orig->datalen };
5060 for (size_t i = 0; i < ret.datalen; i++) {
5061 ret.data[i] = RecentPaymentDetails_clone(&orig->data[i]);
5065 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_ty_from_ptr"))) TS_LDKPaymentSendFailure_ty_from_ptr(uint64_t ptr) {
5066 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5068 case LDKPaymentSendFailure_ParameterError: return 0;
5069 case LDKPaymentSendFailure_PathParameterError: return 1;
5070 case LDKPaymentSendFailure_AllFailedResendSafe: return 2;
5071 case LDKPaymentSendFailure_DuplicatePayment: return 3;
5072 case LDKPaymentSendFailure_PartialFailure: return 4;
5076 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_ParameterError_get_parameter_error"))) TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(uint64_t ptr) {
5077 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5078 assert(obj->tag == LDKPaymentSendFailure_ParameterError);
5079 uint64_t parameter_error_ref = tag_ptr(&obj->parameter_error, false);
5080 return parameter_error_ref;
5082 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error"))) TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(uint64_t ptr) {
5083 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5084 assert(obj->tag == LDKPaymentSendFailure_PathParameterError);
5085 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
5086 uint64_tArray path_parameter_error_arr = NULL;
5087 path_parameter_error_arr = init_uint64_tArray(path_parameter_error_var.datalen, __LINE__);
5088 uint64_t *path_parameter_error_arr_ptr = (uint64_t*)(((uint8_t*)path_parameter_error_arr) + 8);
5089 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
5090 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
5091 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
5092 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
5093 path_parameter_error_arr_ptr[w] = tag_ptr(path_parameter_error_conv_22_conv, true);
5096 return path_parameter_error_arr;
5098 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe"))) TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(uint64_t ptr) {
5099 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5100 assert(obj->tag == LDKPaymentSendFailure_AllFailedResendSafe);
5101 LDKCVec_APIErrorZ all_failed_resend_safe_var = obj->all_failed_resend_safe;
5102 uint64_tArray all_failed_resend_safe_arr = NULL;
5103 all_failed_resend_safe_arr = init_uint64_tArray(all_failed_resend_safe_var.datalen, __LINE__);
5104 uint64_t *all_failed_resend_safe_arr_ptr = (uint64_t*)(((uint8_t*)all_failed_resend_safe_arr) + 8);
5105 for (size_t k = 0; k < all_failed_resend_safe_var.datalen; k++) {
5106 uint64_t all_failed_resend_safe_conv_10_ref = tag_ptr(&all_failed_resend_safe_var.data[k], false);
5107 all_failed_resend_safe_arr_ptr[k] = all_failed_resend_safe_conv_10_ref;
5110 return all_failed_resend_safe_arr;
5112 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_results"))) TS_LDKPaymentSendFailure_PartialFailure_get_results(uint64_t ptr) {
5113 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5114 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
5115 LDKCVec_CResult_NoneAPIErrorZZ results_var = obj->partial_failure.results;
5116 uint64_tArray results_arr = NULL;
5117 results_arr = init_uint64_tArray(results_var.datalen, __LINE__);
5118 uint64_t *results_arr_ptr = (uint64_t*)(((uint8_t*)results_arr) + 8);
5119 for (size_t w = 0; w < results_var.datalen; w++) {
5120 LDKCResult_NoneAPIErrorZ* results_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
5121 *results_conv_22_conv = results_var.data[w];
5122 *results_conv_22_conv = CResult_NoneAPIErrorZ_clone(results_conv_22_conv);
5123 results_arr_ptr[w] = tag_ptr(results_conv_22_conv, true);
5128 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry"))) TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(uint64_t ptr) {
5129 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5130 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
5131 LDKRouteParameters failed_paths_retry_var = obj->partial_failure.failed_paths_retry;
5132 uint64_t failed_paths_retry_ref = 0;
5133 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
5134 failed_paths_retry_ref = tag_ptr(failed_paths_retry_var.inner, false);
5135 return failed_paths_retry_ref;
5137 int8_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_payment_id"))) TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(uint64_t ptr) {
5138 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
5139 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
5140 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
5141 memcpy(payment_id_arr->elems, obj->partial_failure.payment_id.data, 32);
5142 return payment_id_arr;
5144 static inline void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
5145 CHECK(owner->result_ok);
5146 return *owner->contents.result;
5148 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_ok"))) TS_CResult_NonePaymentSendFailureZ_get_ok(uint64_t owner) {
5149 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
5150 CResult_NonePaymentSendFailureZ_get_ok(owner_conv);
5153 static inline struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
5154 CHECK(!owner->result_ok);
5155 return PaymentSendFailure_clone(&*owner->contents.err);
5157 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_err"))) TS_CResult_NonePaymentSendFailureZ_get_err(uint64_t owner) {
5158 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
5159 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
5160 *ret_copy = CResult_NonePaymentSendFailureZ_get_err(owner_conv);
5161 uint64_t ret_ref = tag_ptr(ret_copy, true);
5165 static inline void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner){
5166 CHECK(owner->result_ok);
5167 return *owner->contents.result;
5169 void __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_get_ok"))) TS_CResult_NoneRetryableSendFailureZ_get_ok(uint64_t owner) {
5170 LDKCResult_NoneRetryableSendFailureZ* owner_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(owner);
5171 CResult_NoneRetryableSendFailureZ_get_ok(owner_conv);
5174 static inline enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner){
5175 CHECK(!owner->result_ok);
5176 return RetryableSendFailure_clone(&*owner->contents.err);
5178 uint32_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_get_err"))) TS_CResult_NoneRetryableSendFailureZ_get_err(uint64_t owner) {
5179 LDKCResult_NoneRetryableSendFailureZ* owner_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(owner);
5180 uint32_t ret_conv = LDKRetryableSendFailure_to_js(CResult_NoneRetryableSendFailureZ_get_err(owner_conv));
5184 static inline struct LDKThirtyTwoBytes CResult_PaymentHashPaymentSendFailureZ_get_ok(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner){
5185 CHECK(owner->result_ok);
5186 return ThirtyTwoBytes_clone(&*owner->contents.result);
5188 int8_tArray __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_get_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_get_ok(uint64_t owner) {
5189 LDKCResult_PaymentHashPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(owner);
5190 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5191 memcpy(ret_arr->elems, CResult_PaymentHashPaymentSendFailureZ_get_ok(owner_conv).data, 32);
5195 static inline struct LDKPaymentSendFailure CResult_PaymentHashPaymentSendFailureZ_get_err(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR owner){
5196 CHECK(!owner->result_ok);
5197 return PaymentSendFailure_clone(&*owner->contents.err);
5199 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_get_err"))) TS_CResult_PaymentHashPaymentSendFailureZ_get_err(uint64_t owner) {
5200 LDKCResult_PaymentHashPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(owner);
5201 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
5202 *ret_copy = CResult_PaymentHashPaymentSendFailureZ_get_err(owner_conv);
5203 uint64_t ret_ref = tag_ptr(ret_copy, true);
5207 static inline struct LDKThirtyTwoBytes CResult_PaymentHashRetryableSendFailureZ_get_ok(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner){
5208 CHECK(owner->result_ok);
5209 return ThirtyTwoBytes_clone(&*owner->contents.result);
5211 int8_tArray __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_get_ok"))) TS_CResult_PaymentHashRetryableSendFailureZ_get_ok(uint64_t owner) {
5212 LDKCResult_PaymentHashRetryableSendFailureZ* owner_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(owner);
5213 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5214 memcpy(ret_arr->elems, CResult_PaymentHashRetryableSendFailureZ_get_ok(owner_conv).data, 32);
5218 static inline enum LDKRetryableSendFailure CResult_PaymentHashRetryableSendFailureZ_get_err(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR owner){
5219 CHECK(!owner->result_ok);
5220 return RetryableSendFailure_clone(&*owner->contents.err);
5222 uint32_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_get_err"))) TS_CResult_PaymentHashRetryableSendFailureZ_get_err(uint64_t owner) {
5223 LDKCResult_PaymentHashRetryableSendFailureZ* owner_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(owner);
5224 uint32_t ret_conv = LDKRetryableSendFailure_to_js(CResult_PaymentHashRetryableSendFailureZ_get_err(owner_conv));
5228 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
5229 return ThirtyTwoBytes_clone(&owner->a);
5231 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_a"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_a(uint64_t owner) {
5232 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(owner);
5233 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5234 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_a(owner_conv).data, 32);
5238 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
5239 return ThirtyTwoBytes_clone(&owner->b);
5241 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_b"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_b(uint64_t owner) {
5242 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(owner);
5243 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5244 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_b(owner_conv).data, 32);
5248 static inline struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
5249 CHECK(owner->result_ok);
5250 return C2Tuple_PaymentHashPaymentIdZ_clone(&*owner->contents.result);
5252 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint64_t owner) {
5253 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(owner);
5254 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
5255 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner_conv);
5256 return tag_ptr(ret_conv, true);
5259 static inline struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
5260 CHECK(!owner->result_ok);
5261 return PaymentSendFailure_clone(&*owner->contents.err);
5263 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(uint64_t owner) {
5264 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(owner);
5265 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
5266 *ret_copy = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner_conv);
5267 uint64_t ret_ref = tag_ptr(ret_copy, true);
5271 static inline LDKCVec_ThirtyTwoBytesZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_ThirtyTwoBytesZ *orig) {
5272 LDKCVec_ThirtyTwoBytesZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ThirtyTwoBytesZ clone bytes"), .datalen = orig->datalen };
5273 for (size_t i = 0; i < ret.datalen; i++) {
5274 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
5278 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
5279 return ThirtyTwoBytes_clone(&owner->a);
5281 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_a"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(uint64_t owner) {
5282 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(owner);
5283 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5284 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_a(owner_conv).data, 32);
5288 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
5289 return ThirtyTwoBytes_clone(&owner->b);
5291 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_b"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(uint64_t owner) {
5292 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(owner);
5293 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5294 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_b(owner_conv).data, 32);
5298 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
5299 CHECK(owner->result_ok);
5300 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
5302 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(uint64_t owner) {
5303 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(owner);
5304 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
5305 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner_conv);
5306 return tag_ptr(ret_conv, true);
5309 static inline void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
5310 CHECK(!owner->result_ok);
5311 return *owner->contents.err;
5313 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(uint64_t owner) {
5314 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(owner);
5315 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner_conv);
5318 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
5319 CHECK(owner->result_ok);
5320 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
5322 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(uint64_t owner) {
5323 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(owner);
5324 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
5325 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner_conv);
5326 return tag_ptr(ret_conv, true);
5329 static inline struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
5330 CHECK(!owner->result_ok);
5331 return APIError_clone(&*owner->contents.err);
5333 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(uint64_t owner) {
5334 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(owner);
5335 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5336 *ret_copy = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner_conv);
5337 uint64_t ret_ref = tag_ptr(ret_copy, true);
5341 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
5342 CHECK(owner->result_ok);
5343 return ThirtyTwoBytes_clone(&*owner->contents.result);
5345 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_ok"))) TS_CResult_PaymentSecretNoneZ_get_ok(uint64_t owner) {
5346 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(owner);
5347 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5348 memcpy(ret_arr->elems, CResult_PaymentSecretNoneZ_get_ok(owner_conv).data, 32);
5352 static inline void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
5353 CHECK(!owner->result_ok);
5354 return *owner->contents.err;
5356 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_err"))) TS_CResult_PaymentSecretNoneZ_get_err(uint64_t owner) {
5357 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(owner);
5358 CResult_PaymentSecretNoneZ_get_err(owner_conv);
5361 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
5362 CHECK(owner->result_ok);
5363 return ThirtyTwoBytes_clone(&*owner->contents.result);
5365 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_ok"))) TS_CResult_PaymentSecretAPIErrorZ_get_ok(uint64_t owner) {
5366 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(owner);
5367 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5368 memcpy(ret_arr->elems, CResult_PaymentSecretAPIErrorZ_get_ok(owner_conv).data, 32);
5372 static inline struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
5373 CHECK(!owner->result_ok);
5374 return APIError_clone(&*owner->contents.err);
5376 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_err"))) TS_CResult_PaymentSecretAPIErrorZ_get_err(uint64_t owner) {
5377 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(owner);
5378 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5379 *ret_copy = CResult_PaymentSecretAPIErrorZ_get_err(owner_conv);
5380 uint64_t ret_ref = tag_ptr(ret_copy, true);
5384 static inline struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
5385 CHECK(owner->result_ok);
5386 return ThirtyTwoBytes_clone(&*owner->contents.result);
5388 int8_tArray __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_get_ok(uint64_t owner) {
5389 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(owner);
5390 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5391 memcpy(ret_arr->elems, CResult_PaymentPreimageAPIErrorZ_get_ok(owner_conv).data, 32);
5395 static inline struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
5396 CHECK(!owner->result_ok);
5397 return APIError_clone(&*owner->contents.err);
5399 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_err"))) TS_CResult_PaymentPreimageAPIErrorZ_get_err(uint64_t owner) {
5400 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(owner);
5401 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5402 *ret_copy = CResult_PaymentPreimageAPIErrorZ_get_err(owner_conv);
5403 uint64_t ret_ref = tag_ptr(ret_copy, true);
5407 static inline struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5408 LDKCounterpartyForwardingInfo ret = *owner->contents.result;
5409 ret.is_owned = false;
5412 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(uint64_t owner) {
5413 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5414 LDKCounterpartyForwardingInfo ret_var = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner_conv);
5415 uint64_t ret_ref = 0;
5416 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5417 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5421 static inline struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5422 CHECK(!owner->result_ok);
5423 return DecodeError_clone(&*owner->contents.err);
5425 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(uint64_t owner) {
5426 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5427 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5428 *ret_copy = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner_conv);
5429 uint64_t ret_ref = tag_ptr(ret_copy, true);
5433 static inline struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5434 LDKChannelCounterparty ret = *owner->contents.result;
5435 ret.is_owned = false;
5438 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(uint64_t owner) {
5439 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5440 LDKChannelCounterparty ret_var = CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner_conv);
5441 uint64_t ret_ref = 0;
5442 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5443 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5447 static inline struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5448 CHECK(!owner->result_ok);
5449 return DecodeError_clone(&*owner->contents.err);
5451 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(uint64_t owner) {
5452 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5453 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5454 *ret_copy = CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner_conv);
5455 uint64_t ret_ref = tag_ptr(ret_copy, true);
5459 static inline struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5460 LDKChannelDetails ret = *owner->contents.result;
5461 ret.is_owned = false;
5464 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(uint64_t owner) {
5465 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5466 LDKChannelDetails ret_var = CResult_ChannelDetailsDecodeErrorZ_get_ok(owner_conv);
5467 uint64_t ret_ref = 0;
5468 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5469 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5473 static inline struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5474 CHECK(!owner->result_ok);
5475 return DecodeError_clone(&*owner->contents.err);
5477 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_err(uint64_t owner) {
5478 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5479 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5480 *ret_copy = CResult_ChannelDetailsDecodeErrorZ_get_err(owner_conv);
5481 uint64_t ret_ref = tag_ptr(ret_copy, true);
5485 static inline struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5486 LDKPhantomRouteHints ret = *owner->contents.result;
5487 ret.is_owned = false;
5490 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(uint64_t owner) {
5491 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5492 LDKPhantomRouteHints ret_var = CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner_conv);
5493 uint64_t ret_ref = 0;
5494 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5495 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5499 static inline struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5500 CHECK(!owner->result_ok);
5501 return DecodeError_clone(&*owner->contents.err);
5503 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(uint64_t owner) {
5504 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5505 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5506 *ret_copy = CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner_conv);
5507 uint64_t ret_ref = tag_ptr(ret_copy, true);
5511 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
5512 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
5513 for (size_t i = 0; i < ret.datalen; i++) {
5514 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
5518 typedef struct LDKWatch_JCalls {
5519 atomic_size_t refcnt;
5520 uint32_t instance_ptr;
5522 static void LDKWatch_JCalls_free(void* this_arg) {
5523 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5524 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5528 LDKChannelMonitorUpdateStatus watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
5529 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5530 LDKOutPoint funding_txo_var = funding_txo;
5531 uint64_t funding_txo_ref = 0;
5532 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5533 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5534 LDKChannelMonitor monitor_var = monitor;
5535 uint64_t monitor_ref = 0;
5536 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
5537 monitor_ref = tag_ptr(monitor_var.inner, monitor_var.is_owned);
5538 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 17, funding_txo_ref, monitor_ref, 0, 0, 0, 0);
5539 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5542 LDKChannelMonitorUpdateStatus update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, const LDKChannelMonitorUpdate * update) {
5543 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5544 LDKOutPoint funding_txo_var = funding_txo;
5545 uint64_t funding_txo_ref = 0;
5546 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5547 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5548 LDKChannelMonitorUpdate update_var = *update;
5549 uint64_t update_ref = 0;
5550 update_var = ChannelMonitorUpdate_clone(&update_var);
5551 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
5552 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
5553 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 18, funding_txo_ref, update_ref, 0, 0, 0, 0);
5554 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5557 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
5558 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5559 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 19, 0, 0, 0, 0, 0, 0);
5560 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_constr;
5561 ret_constr.datalen = ret->arr_len;
5562 if (ret_constr.datalen > 0)
5563 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
5565 ret_constr.data = NULL;
5566 uint64_t* ret_vals = ret->elems;
5567 for (size_t x = 0; x < ret_constr.datalen; x++) {
5568 uint64_t ret_conv_49 = ret_vals[x];
5569 void* ret_conv_49_ptr = untag_ptr(ret_conv_49);
5570 CHECK_ACCESS(ret_conv_49_ptr);
5571 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ ret_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(ret_conv_49_ptr);
5572 FREE(untag_ptr(ret_conv_49));
5573 ret_constr.data[x] = ret_conv_49_conv;
5578 static void LDKWatch_JCalls_cloned(LDKWatch* new_obj) {
5579 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) new_obj->this_arg;
5580 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5582 static inline LDKWatch LDKWatch_init (JSValue o) {
5583 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
5584 atomic_init(&calls->refcnt, 1);
5585 calls->instance_ptr = o;
5588 .this_arg = (void*) calls,
5589 .watch_channel = watch_channel_LDKWatch_jcall,
5590 .update_channel = update_channel_LDKWatch_jcall,
5591 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
5592 .free = LDKWatch_JCalls_free,
5596 uint64_t __attribute__((export_name("TS_LDKWatch_new"))) TS_LDKWatch_new(JSValue o) {
5597 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
5598 *res_ptr = LDKWatch_init(o);
5599 return tag_ptr(res_ptr, true);
5601 uint32_t __attribute__((export_name("TS_Watch_watch_channel"))) TS_Watch_watch_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t monitor) {
5602 void* this_arg_ptr = untag_ptr(this_arg);
5603 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5604 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5605 LDKOutPoint funding_txo_conv;
5606 funding_txo_conv.inner = untag_ptr(funding_txo);
5607 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5608 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5609 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5610 LDKChannelMonitor monitor_conv;
5611 monitor_conv.inner = untag_ptr(monitor);
5612 monitor_conv.is_owned = ptr_is_owned(monitor);
5613 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
5614 monitor_conv = ChannelMonitor_clone(&monitor_conv);
5615 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv));
5619 uint32_t __attribute__((export_name("TS_Watch_update_channel"))) TS_Watch_update_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t update) {
5620 void* this_arg_ptr = untag_ptr(this_arg);
5621 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5622 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5623 LDKOutPoint funding_txo_conv;
5624 funding_txo_conv.inner = untag_ptr(funding_txo);
5625 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5626 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5627 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5628 LDKChannelMonitorUpdate update_conv;
5629 update_conv.inner = untag_ptr(update);
5630 update_conv.is_owned = ptr_is_owned(update);
5631 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
5632 update_conv.is_owned = false;
5633 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, &update_conv));
5637 uint64_tArray __attribute__((export_name("TS_Watch_release_pending_monitor_events"))) TS_Watch_release_pending_monitor_events(uint64_t this_arg) {
5638 void* this_arg_ptr = untag_ptr(this_arg);
5639 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5640 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5641 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
5642 uint64_tArray ret_arr = NULL;
5643 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
5644 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
5645 for (size_t x = 0; x < ret_var.datalen; x++) {
5646 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv_49_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
5647 *ret_conv_49_conv = ret_var.data[x];
5648 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
5655 typedef struct LDKBroadcasterInterface_JCalls {
5656 atomic_size_t refcnt;
5657 uint32_t instance_ptr;
5658 } LDKBroadcasterInterface_JCalls;
5659 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
5660 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5661 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5665 void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
5666 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5667 LDKTransaction tx_var = tx;
5668 int8_tArray tx_arr = init_int8_tArray(tx_var.datalen, __LINE__);
5669 memcpy(tx_arr->elems, tx_var.data, tx_var.datalen);
5670 Transaction_free(tx_var);
5671 js_invoke_function_uuuuuu(j_calls->instance_ptr, 20, (uint32_t)tx_arr, 0, 0, 0, 0, 0);
5673 static void LDKBroadcasterInterface_JCalls_cloned(LDKBroadcasterInterface* new_obj) {
5674 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) new_obj->this_arg;
5675 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5677 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JSValue o) {
5678 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
5679 atomic_init(&calls->refcnt, 1);
5680 calls->instance_ptr = o;
5682 LDKBroadcasterInterface ret = {
5683 .this_arg = (void*) calls,
5684 .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
5685 .free = LDKBroadcasterInterface_JCalls_free,
5689 uint64_t __attribute__((export_name("TS_LDKBroadcasterInterface_new"))) TS_LDKBroadcasterInterface_new(JSValue o) {
5690 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
5691 *res_ptr = LDKBroadcasterInterface_init(o);
5692 return tag_ptr(res_ptr, true);
5694 void __attribute__((export_name("TS_BroadcasterInterface_broadcast_transaction"))) TS_BroadcasterInterface_broadcast_transaction(uint64_t this_arg, int8_tArray tx) {
5695 void* this_arg_ptr = untag_ptr(this_arg);
5696 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5697 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)this_arg_ptr;
5698 LDKTransaction tx_ref;
5699 tx_ref.datalen = tx->arr_len;
5700 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
5701 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
5702 tx_ref.data_is_owned = true;
5703 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
5706 typedef struct LDKEntropySource_JCalls {
5707 atomic_size_t refcnt;
5708 uint32_t instance_ptr;
5709 } LDKEntropySource_JCalls;
5710 static void LDKEntropySource_JCalls_free(void* this_arg) {
5711 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) this_arg;
5712 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5716 LDKThirtyTwoBytes get_secure_random_bytes_LDKEntropySource_jcall(const void* this_arg) {
5717 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) this_arg;
5718 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 21, 0, 0, 0, 0, 0, 0);
5719 LDKThirtyTwoBytes ret_ref;
5720 CHECK(ret->arr_len == 32);
5721 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5724 static void LDKEntropySource_JCalls_cloned(LDKEntropySource* new_obj) {
5725 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) new_obj->this_arg;
5726 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5728 static inline LDKEntropySource LDKEntropySource_init (JSValue o) {
5729 LDKEntropySource_JCalls *calls = MALLOC(sizeof(LDKEntropySource_JCalls), "LDKEntropySource_JCalls");
5730 atomic_init(&calls->refcnt, 1);
5731 calls->instance_ptr = o;
5733 LDKEntropySource ret = {
5734 .this_arg = (void*) calls,
5735 .get_secure_random_bytes = get_secure_random_bytes_LDKEntropySource_jcall,
5736 .free = LDKEntropySource_JCalls_free,
5740 uint64_t __attribute__((export_name("TS_LDKEntropySource_new"))) TS_LDKEntropySource_new(JSValue o) {
5741 LDKEntropySource *res_ptr = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
5742 *res_ptr = LDKEntropySource_init(o);
5743 return tag_ptr(res_ptr, true);
5745 int8_tArray __attribute__((export_name("TS_EntropySource_get_secure_random_bytes"))) TS_EntropySource_get_secure_random_bytes(uint64_t this_arg) {
5746 void* this_arg_ptr = untag_ptr(this_arg);
5747 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5748 LDKEntropySource* this_arg_conv = (LDKEntropySource*)this_arg_ptr;
5749 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5750 memcpy(ret_arr->elems, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data, 32);
5754 uint32_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ty_from_ptr"))) TS_LDKUnsignedGossipMessage_ty_from_ptr(uint64_t ptr) {
5755 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5757 case LDKUnsignedGossipMessage_ChannelAnnouncement: return 0;
5758 case LDKUnsignedGossipMessage_ChannelUpdate: return 1;
5759 case LDKUnsignedGossipMessage_NodeAnnouncement: return 2;
5763 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement"))) TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(uint64_t ptr) {
5764 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5765 assert(obj->tag == LDKUnsignedGossipMessage_ChannelAnnouncement);
5766 LDKUnsignedChannelAnnouncement channel_announcement_var = obj->channel_announcement;
5767 uint64_t channel_announcement_ref = 0;
5768 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_announcement_var);
5769 channel_announcement_ref = tag_ptr(channel_announcement_var.inner, false);
5770 return channel_announcement_ref;
5772 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update"))) TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(uint64_t ptr) {
5773 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5774 assert(obj->tag == LDKUnsignedGossipMessage_ChannelUpdate);
5775 LDKUnsignedChannelUpdate channel_update_var = obj->channel_update;
5776 uint64_t channel_update_ref = 0;
5777 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_update_var);
5778 channel_update_ref = tag_ptr(channel_update_var.inner, false);
5779 return channel_update_ref;
5781 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement"))) TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(uint64_t ptr) {
5782 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5783 assert(obj->tag == LDKUnsignedGossipMessage_NodeAnnouncement);
5784 LDKUnsignedNodeAnnouncement node_announcement_var = obj->node_announcement;
5785 uint64_t node_announcement_ref = 0;
5786 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_announcement_var);
5787 node_announcement_ref = tag_ptr(node_announcement_var.inner, false);
5788 return node_announcement_ref;
5790 typedef struct LDKNodeSigner_JCalls {
5791 atomic_size_t refcnt;
5792 uint32_t instance_ptr;
5793 } LDKNodeSigner_JCalls;
5794 static void LDKNodeSigner_JCalls_free(void* this_arg) {
5795 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5796 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5800 LDKThirtyTwoBytes get_inbound_payment_key_material_LDKNodeSigner_jcall(const void* this_arg) {
5801 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5802 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 22, 0, 0, 0, 0, 0, 0);
5803 LDKThirtyTwoBytes ret_ref;
5804 CHECK(ret->arr_len == 32);
5805 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5808 LDKCResult_PublicKeyNoneZ get_node_id_LDKNodeSigner_jcall(const void* this_arg, LDKRecipient recipient) {
5809 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5810 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5811 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 23, recipient_conv, 0, 0, 0, 0, 0);
5812 void* ret_ptr = untag_ptr(ret);
5813 CHECK_ACCESS(ret_ptr);
5814 LDKCResult_PublicKeyNoneZ ret_conv = *(LDKCResult_PublicKeyNoneZ*)(ret_ptr);
5815 FREE(untag_ptr(ret));
5818 LDKCResult_SharedSecretNoneZ ecdh_LDKNodeSigner_jcall(const void* this_arg, LDKRecipient recipient, LDKPublicKey other_key, LDKCOption_ScalarZ tweak) {
5819 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5820 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5821 int8_tArray other_key_arr = init_int8_tArray(33, __LINE__);
5822 memcpy(other_key_arr->elems, other_key.compressed_form, 33);
5823 LDKCOption_ScalarZ *tweak_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
5824 *tweak_copy = tweak;
5825 uint64_t tweak_ref = tag_ptr(tweak_copy, true);
5826 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 24, recipient_conv, (uint32_t)other_key_arr, tweak_ref, 0, 0, 0);
5827 void* ret_ptr = untag_ptr(ret);
5828 CHECK_ACCESS(ret_ptr);
5829 LDKCResult_SharedSecretNoneZ ret_conv = *(LDKCResult_SharedSecretNoneZ*)(ret_ptr);
5830 FREE(untag_ptr(ret));
5833 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKNodeSigner_jcall(const void* this_arg, LDKu8slice hrp_bytes, LDKCVec_U5Z invoice_data, LDKRecipient recipient) {
5834 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5835 LDKu8slice hrp_bytes_var = hrp_bytes;
5836 int8_tArray hrp_bytes_arr = init_int8_tArray(hrp_bytes_var.datalen, __LINE__);
5837 memcpy(hrp_bytes_arr->elems, hrp_bytes_var.data, hrp_bytes_var.datalen);
5838 LDKCVec_U5Z invoice_data_var = invoice_data;
5839 ptrArray invoice_data_arr = NULL;
5840 invoice_data_arr = init_ptrArray(invoice_data_var.datalen, __LINE__);
5841 int8_t *invoice_data_arr_ptr = (int8_t*)(((uint8_t*)invoice_data_arr) + 8);
5842 for (size_t h = 0; h < invoice_data_var.datalen; h++) {
5843 uint8_t invoice_data_conv_7_val = invoice_data_var.data[h]._0;
5844 invoice_data_arr_ptr[h] = invoice_data_conv_7_val;
5847 FREE(invoice_data_var.data);
5848 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5849 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);
5850 void* ret_ptr = untag_ptr(ret);
5851 CHECK_ACCESS(ret_ptr);
5852 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
5853 FREE(untag_ptr(ret));
5856 LDKCResult_SignatureNoneZ sign_gossip_message_LDKNodeSigner_jcall(const void* this_arg, LDKUnsignedGossipMessage msg) {
5857 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5858 LDKUnsignedGossipMessage *msg_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
5860 uint64_t msg_ref = tag_ptr(msg_copy, true);
5861 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 26, msg_ref, 0, 0, 0, 0, 0);
5862 void* ret_ptr = untag_ptr(ret);
5863 CHECK_ACCESS(ret_ptr);
5864 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
5865 FREE(untag_ptr(ret));
5868 static void LDKNodeSigner_JCalls_cloned(LDKNodeSigner* new_obj) {
5869 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) new_obj->this_arg;
5870 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5872 static inline LDKNodeSigner LDKNodeSigner_init (JSValue o) {
5873 LDKNodeSigner_JCalls *calls = MALLOC(sizeof(LDKNodeSigner_JCalls), "LDKNodeSigner_JCalls");
5874 atomic_init(&calls->refcnt, 1);
5875 calls->instance_ptr = o;
5877 LDKNodeSigner ret = {
5878 .this_arg = (void*) calls,
5879 .get_inbound_payment_key_material = get_inbound_payment_key_material_LDKNodeSigner_jcall,
5880 .get_node_id = get_node_id_LDKNodeSigner_jcall,
5881 .ecdh = ecdh_LDKNodeSigner_jcall,
5882 .sign_invoice = sign_invoice_LDKNodeSigner_jcall,
5883 .sign_gossip_message = sign_gossip_message_LDKNodeSigner_jcall,
5884 .free = LDKNodeSigner_JCalls_free,
5888 uint64_t __attribute__((export_name("TS_LDKNodeSigner_new"))) TS_LDKNodeSigner_new(JSValue o) {
5889 LDKNodeSigner *res_ptr = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
5890 *res_ptr = LDKNodeSigner_init(o);
5891 return tag_ptr(res_ptr, true);
5893 int8_tArray __attribute__((export_name("TS_NodeSigner_get_inbound_payment_key_material"))) TS_NodeSigner_get_inbound_payment_key_material(uint64_t this_arg) {
5894 void* this_arg_ptr = untag_ptr(this_arg);
5895 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5896 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5897 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5898 memcpy(ret_arr->elems, (this_arg_conv->get_inbound_payment_key_material)(this_arg_conv->this_arg).data, 32);
5902 uint64_t __attribute__((export_name("TS_NodeSigner_get_node_id"))) TS_NodeSigner_get_node_id(uint64_t this_arg, uint32_t recipient) {
5903 void* this_arg_ptr = untag_ptr(this_arg);
5904 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5905 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5906 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5907 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
5908 *ret_conv = (this_arg_conv->get_node_id)(this_arg_conv->this_arg, recipient_conv);
5909 return tag_ptr(ret_conv, true);
5912 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) {
5913 void* this_arg_ptr = untag_ptr(this_arg);
5914 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5915 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5916 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5917 LDKPublicKey other_key_ref;
5918 CHECK(other_key->arr_len == 33);
5919 memcpy(other_key_ref.compressed_form, other_key->elems, 33); FREE(other_key);
5920 void* tweak_ptr = untag_ptr(tweak);
5921 CHECK_ACCESS(tweak_ptr);
5922 LDKCOption_ScalarZ tweak_conv = *(LDKCOption_ScalarZ*)(tweak_ptr);
5923 tweak_conv = COption_ScalarZ_clone((LDKCOption_ScalarZ*)untag_ptr(tweak));
5924 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
5925 *ret_conv = (this_arg_conv->ecdh)(this_arg_conv->this_arg, recipient_conv, other_key_ref, tweak_conv);
5926 return tag_ptr(ret_conv, true);
5929 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) {
5930 void* this_arg_ptr = untag_ptr(this_arg);
5931 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5932 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5933 LDKu8slice hrp_bytes_ref;
5934 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
5935 hrp_bytes_ref.data = hrp_bytes->elems;
5936 LDKCVec_U5Z invoice_data_constr;
5937 invoice_data_constr.datalen = invoice_data->arr_len;
5938 if (invoice_data_constr.datalen > 0)
5939 invoice_data_constr.data = MALLOC(invoice_data_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
5941 invoice_data_constr.data = NULL;
5942 int8_t* invoice_data_vals = (void*) invoice_data->elems;
5943 for (size_t h = 0; h < invoice_data_constr.datalen; h++) {
5944 int8_t invoice_data_conv_7 = invoice_data_vals[h];
5946 invoice_data_constr.data[h] = (LDKU5){ ._0 = invoice_data_conv_7 };
5949 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5950 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
5951 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, hrp_bytes_ref, invoice_data_constr, recipient_conv);
5953 return tag_ptr(ret_conv, true);
5956 uint64_t __attribute__((export_name("TS_NodeSigner_sign_gossip_message"))) TS_NodeSigner_sign_gossip_message(uint64_t this_arg, uint64_t msg) {
5957 void* this_arg_ptr = untag_ptr(this_arg);
5958 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5959 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5960 void* msg_ptr = untag_ptr(msg);
5961 CHECK_ACCESS(msg_ptr);
5962 LDKUnsignedGossipMessage msg_conv = *(LDKUnsignedGossipMessage*)(msg_ptr);
5963 msg_conv = UnsignedGossipMessage_clone((LDKUnsignedGossipMessage*)untag_ptr(msg));
5964 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
5965 *ret_conv = (this_arg_conv->sign_gossip_message)(this_arg_conv->this_arg, msg_conv);
5966 return tag_ptr(ret_conv, true);
5969 typedef struct LDKSignerProvider_JCalls {
5970 atomic_size_t refcnt;
5971 uint32_t instance_ptr;
5972 } LDKSignerProvider_JCalls;
5973 static void LDKSignerProvider_JCalls_free(void* this_arg) {
5974 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5975 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5979 LDKThirtyTwoBytes generate_channel_keys_id_LDKSignerProvider_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis, LDKU128 user_channel_id) {
5980 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5981 jboolean inbound_conv = inbound;
5982 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5983 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
5984 memcpy(user_channel_id_arr->elems, user_channel_id.le_bytes, 16);
5985 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);
5986 LDKThirtyTwoBytes ret_ref;
5987 CHECK(ret->arr_len == 32);
5988 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5991 LDKWriteableEcdsaChannelSigner derive_channel_signer_LDKSignerProvider_jcall(const void* this_arg, uint64_t channel_value_satoshis, LDKThirtyTwoBytes channel_keys_id) {
5992 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5993 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5994 int8_tArray channel_keys_id_arr = init_int8_tArray(32, __LINE__);
5995 memcpy(channel_keys_id_arr->elems, channel_keys_id.data, 32);
5996 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);
5997 void* ret_ptr = untag_ptr(ret);
5998 CHECK_ACCESS(ret_ptr);
5999 LDKWriteableEcdsaChannelSigner ret_conv = *(LDKWriteableEcdsaChannelSigner*)(ret_ptr);
6000 FREE(untag_ptr(ret));
6003 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer_LDKSignerProvider_jcall(const void* this_arg, LDKu8slice reader) {
6004 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
6005 LDKu8slice reader_var = reader;
6006 int8_tArray reader_arr = init_int8_tArray(reader_var.datalen, __LINE__);
6007 memcpy(reader_arr->elems, reader_var.data, reader_var.datalen);
6008 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 29, (uint32_t)reader_arr, 0, 0, 0, 0, 0);
6009 void* ret_ptr = untag_ptr(ret);
6010 CHECK_ACCESS(ret_ptr);
6011 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ ret_conv = *(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)(ret_ptr);
6012 FREE(untag_ptr(ret));
6015 LDKCVec_u8Z get_destination_script_LDKSignerProvider_jcall(const void* this_arg) {
6016 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
6017 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 30, 0, 0, 0, 0, 0, 0);
6018 LDKCVec_u8Z ret_ref;
6019 ret_ref.datalen = ret->arr_len;
6020 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6021 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6024 LDKShutdownScript get_shutdown_scriptpubkey_LDKSignerProvider_jcall(const void* this_arg) {
6025 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
6026 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 31, 0, 0, 0, 0, 0, 0);
6027 LDKShutdownScript ret_conv;
6028 ret_conv.inner = untag_ptr(ret);
6029 ret_conv.is_owned = ptr_is_owned(ret);
6030 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
6033 static void LDKSignerProvider_JCalls_cloned(LDKSignerProvider* new_obj) {
6034 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) new_obj->this_arg;
6035 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6037 static inline LDKSignerProvider LDKSignerProvider_init (JSValue o) {
6038 LDKSignerProvider_JCalls *calls = MALLOC(sizeof(LDKSignerProvider_JCalls), "LDKSignerProvider_JCalls");
6039 atomic_init(&calls->refcnt, 1);
6040 calls->instance_ptr = o;
6042 LDKSignerProvider ret = {
6043 .this_arg = (void*) calls,
6044 .generate_channel_keys_id = generate_channel_keys_id_LDKSignerProvider_jcall,
6045 .derive_channel_signer = derive_channel_signer_LDKSignerProvider_jcall,
6046 .read_chan_signer = read_chan_signer_LDKSignerProvider_jcall,
6047 .get_destination_script = get_destination_script_LDKSignerProvider_jcall,
6048 .get_shutdown_scriptpubkey = get_shutdown_scriptpubkey_LDKSignerProvider_jcall,
6049 .free = LDKSignerProvider_JCalls_free,
6053 uint64_t __attribute__((export_name("TS_LDKSignerProvider_new"))) TS_LDKSignerProvider_new(JSValue o) {
6054 LDKSignerProvider *res_ptr = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
6055 *res_ptr = LDKSignerProvider_init(o);
6056 return tag_ptr(res_ptr, true);
6058 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) {
6059 void* this_arg_ptr = untag_ptr(this_arg);
6060 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6061 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6062 LDKU128 user_channel_id_ref;
6063 CHECK(user_channel_id->arr_len == 16);
6064 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
6065 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6066 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);
6070 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) {
6071 void* this_arg_ptr = untag_ptr(this_arg);
6072 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6073 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6074 LDKThirtyTwoBytes channel_keys_id_ref;
6075 CHECK(channel_keys_id->arr_len == 32);
6076 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
6077 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
6078 *ret_ret = (this_arg_conv->derive_channel_signer)(this_arg_conv->this_arg, channel_value_satoshis, channel_keys_id_ref);
6079 return tag_ptr(ret_ret, true);
6082 uint64_t __attribute__((export_name("TS_SignerProvider_read_chan_signer"))) TS_SignerProvider_read_chan_signer(uint64_t this_arg, int8_tArray reader) {
6083 void* this_arg_ptr = untag_ptr(this_arg);
6084 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6085 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6086 LDKu8slice reader_ref;
6087 reader_ref.datalen = reader->arr_len;
6088 reader_ref.data = reader->elems;
6089 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
6090 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
6092 return tag_ptr(ret_conv, true);
6095 int8_tArray __attribute__((export_name("TS_SignerProvider_get_destination_script"))) TS_SignerProvider_get_destination_script(uint64_t this_arg) {
6096 void* this_arg_ptr = untag_ptr(this_arg);
6097 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6098 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6099 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
6100 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6101 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6102 CVec_u8Z_free(ret_var);
6106 uint64_t __attribute__((export_name("TS_SignerProvider_get_shutdown_scriptpubkey"))) TS_SignerProvider_get_shutdown_scriptpubkey(uint64_t this_arg) {
6107 void* this_arg_ptr = untag_ptr(this_arg);
6108 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6109 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
6110 LDKShutdownScript ret_var = (this_arg_conv->get_shutdown_scriptpubkey)(this_arg_conv->this_arg);
6111 uint64_t ret_ref = 0;
6112 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6113 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6117 typedef struct LDKFeeEstimator_JCalls {
6118 atomic_size_t refcnt;
6119 uint32_t instance_ptr;
6120 } LDKFeeEstimator_JCalls;
6121 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
6122 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
6123 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6127 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
6128 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
6129 uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
6130 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 32, confirmation_target_conv, 0, 0, 0, 0, 0);
6132 static void LDKFeeEstimator_JCalls_cloned(LDKFeeEstimator* new_obj) {
6133 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) new_obj->this_arg;
6134 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6136 static inline LDKFeeEstimator LDKFeeEstimator_init (JSValue o) {
6137 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
6138 atomic_init(&calls->refcnt, 1);
6139 calls->instance_ptr = o;
6141 LDKFeeEstimator ret = {
6142 .this_arg = (void*) calls,
6143 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
6144 .free = LDKFeeEstimator_JCalls_free,
6148 uint64_t __attribute__((export_name("TS_LDKFeeEstimator_new"))) TS_LDKFeeEstimator_new(JSValue o) {
6149 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
6150 *res_ptr = LDKFeeEstimator_init(o);
6151 return tag_ptr(res_ptr, true);
6153 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) {
6154 void* this_arg_ptr = untag_ptr(this_arg);
6155 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6156 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)this_arg_ptr;
6157 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_js(confirmation_target);
6158 int32_t ret_conv = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
6162 typedef struct LDKRouter_JCalls {
6163 atomic_size_t refcnt;
6164 uint32_t instance_ptr;
6166 static void LDKRouter_JCalls_free(void* this_arg) {
6167 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
6168 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6172 LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, const LDKInFlightHtlcs * inflight_htlcs) {
6173 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
6174 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
6175 memcpy(payer_arr->elems, payer.compressed_form, 33);
6176 LDKRouteParameters route_params_var = *route_params;
6177 uint64_t route_params_ref = 0;
6178 route_params_var = RouteParameters_clone(&route_params_var);
6179 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
6180 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
6181 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
6182 uint64_tArray first_hops_arr = NULL;
6183 if (first_hops != NULL) {
6184 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
6185 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
6186 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
6187 for (size_t q = 0; q < first_hops_var.datalen; q++) {
6188 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
6189 uint64_t first_hops_conv_16_ref = 0;
6190 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
6191 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
6192 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
6196 LDKInFlightHtlcs inflight_htlcs_var = *inflight_htlcs;
6197 uint64_t inflight_htlcs_ref = 0;
6198 inflight_htlcs_var = InFlightHtlcs_clone(&inflight_htlcs_var);
6199 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
6200 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
6201 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);
6202 void* ret_ptr = untag_ptr(ret);
6203 CHECK_ACCESS(ret_ptr);
6204 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
6205 FREE(untag_ptr(ret));
6208 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) {
6209 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
6210 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
6211 memcpy(payer_arr->elems, payer.compressed_form, 33);
6212 LDKRouteParameters route_params_var = *route_params;
6213 uint64_t route_params_ref = 0;
6214 route_params_var = RouteParameters_clone(&route_params_var);
6215 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
6216 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
6217 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
6218 uint64_tArray first_hops_arr = NULL;
6219 if (first_hops != NULL) {
6220 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
6221 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
6222 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
6223 for (size_t q = 0; q < first_hops_var.datalen; q++) {
6224 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
6225 uint64_t first_hops_conv_16_ref = 0;
6226 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
6227 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
6228 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
6232 LDKInFlightHtlcs inflight_htlcs_var = *inflight_htlcs;
6233 uint64_t inflight_htlcs_ref = 0;
6234 inflight_htlcs_var = InFlightHtlcs_clone(&inflight_htlcs_var);
6235 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
6236 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
6237 int8_tArray _payment_hash_arr = init_int8_tArray(32, __LINE__);
6238 memcpy(_payment_hash_arr->elems, _payment_hash.data, 32);
6239 int8_tArray _payment_id_arr = init_int8_tArray(32, __LINE__);
6240 memcpy(_payment_id_arr->elems, _payment_id.data, 32);
6241 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);
6242 void* ret_ptr = untag_ptr(ret);
6243 CHECK_ACCESS(ret_ptr);
6244 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
6245 FREE(untag_ptr(ret));
6248 static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
6249 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) new_obj->this_arg;
6250 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6252 static inline LDKRouter LDKRouter_init (JSValue o) {
6253 LDKRouter_JCalls *calls = MALLOC(sizeof(LDKRouter_JCalls), "LDKRouter_JCalls");
6254 atomic_init(&calls->refcnt, 1);
6255 calls->instance_ptr = o;
6258 .this_arg = (void*) calls,
6259 .find_route = find_route_LDKRouter_jcall,
6260 .find_route_with_id = find_route_with_id_LDKRouter_jcall,
6261 .free = LDKRouter_JCalls_free,
6265 uint64_t __attribute__((export_name("TS_LDKRouter_new"))) TS_LDKRouter_new(JSValue o) {
6266 LDKRouter *res_ptr = MALLOC(sizeof(LDKRouter), "LDKRouter");
6267 *res_ptr = LDKRouter_init(o);
6268 return tag_ptr(res_ptr, true);
6270 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) {
6271 void* this_arg_ptr = untag_ptr(this_arg);
6272 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6273 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
6274 LDKPublicKey payer_ref;
6275 CHECK(payer->arr_len == 33);
6276 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
6277 LDKRouteParameters route_params_conv;
6278 route_params_conv.inner = untag_ptr(route_params);
6279 route_params_conv.is_owned = ptr_is_owned(route_params);
6280 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
6281 route_params_conv.is_owned = false;
6282 LDKCVec_ChannelDetailsZ first_hops_constr;
6283 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
6284 if (first_hops != 0) {
6285 first_hops_constr.datalen = first_hops->arr_len;
6286 if (first_hops_constr.datalen > 0)
6287 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
6289 first_hops_constr.data = NULL;
6290 uint64_t* first_hops_vals = first_hops->elems;
6291 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
6292 uint64_t first_hops_conv_16 = first_hops_vals[q];
6293 LDKChannelDetails first_hops_conv_16_conv;
6294 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
6295 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
6296 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
6297 first_hops_conv_16_conv.is_owned = false;
6298 first_hops_constr.data[q] = first_hops_conv_16_conv;
6301 first_hops_ptr = &first_hops_constr;
6303 LDKInFlightHtlcs inflight_htlcs_conv;
6304 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
6305 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
6306 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
6307 inflight_htlcs_conv.is_owned = false;
6308 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
6309 *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, first_hops_ptr, &inflight_htlcs_conv);
6310 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
6311 return tag_ptr(ret_conv, true);
6314 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) {
6315 void* this_arg_ptr = untag_ptr(this_arg);
6316 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6317 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
6318 LDKPublicKey payer_ref;
6319 CHECK(payer->arr_len == 33);
6320 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
6321 LDKRouteParameters route_params_conv;
6322 route_params_conv.inner = untag_ptr(route_params);
6323 route_params_conv.is_owned = ptr_is_owned(route_params);
6324 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
6325 route_params_conv.is_owned = false;
6326 LDKCVec_ChannelDetailsZ first_hops_constr;
6327 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
6328 if (first_hops != 0) {
6329 first_hops_constr.datalen = first_hops->arr_len;
6330 if (first_hops_constr.datalen > 0)
6331 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
6333 first_hops_constr.data = NULL;
6334 uint64_t* first_hops_vals = first_hops->elems;
6335 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
6336 uint64_t first_hops_conv_16 = first_hops_vals[q];
6337 LDKChannelDetails first_hops_conv_16_conv;
6338 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
6339 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
6340 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
6341 first_hops_conv_16_conv.is_owned = false;
6342 first_hops_constr.data[q] = first_hops_conv_16_conv;
6345 first_hops_ptr = &first_hops_constr;
6347 LDKInFlightHtlcs inflight_htlcs_conv;
6348 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
6349 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
6350 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
6351 inflight_htlcs_conv.is_owned = false;
6352 LDKThirtyTwoBytes _payment_hash_ref;
6353 CHECK(_payment_hash->arr_len == 32);
6354 memcpy(_payment_hash_ref.data, _payment_hash->elems, 32); FREE(_payment_hash);
6355 LDKThirtyTwoBytes _payment_id_ref;
6356 CHECK(_payment_id->arr_len == 32);
6357 memcpy(_payment_id_ref.data, _payment_id->elems, 32); FREE(_payment_id);
6358 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
6359 *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);
6360 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
6361 return tag_ptr(ret_conv, true);
6364 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
6365 return ThirtyTwoBytes_clone(&owner->a);
6367 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_a"))) TS_C2Tuple_BlockHashChannelManagerZ_get_a(uint64_t owner) {
6368 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)untag_ptr(owner);
6369 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6370 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelManagerZ_get_a(owner_conv).data, 32);
6374 static inline struct LDKChannelManager C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
6375 LDKChannelManager ret = owner->b;
6376 ret.is_owned = false;
6379 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_b"))) TS_C2Tuple_BlockHashChannelManagerZ_get_b(uint64_t owner) {
6380 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)untag_ptr(owner);
6381 LDKChannelManager ret_var = C2Tuple_BlockHashChannelManagerZ_get_b(owner_conv);
6382 uint64_t ret_ref = 0;
6383 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6384 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6388 static inline struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
6389 CHECK(owner->result_ok);
6390 return &*owner->contents.result;
6392 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint64_t owner) {
6393 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(owner);
6394 uint64_t ret_ret = tag_ptr(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner_conv), false);
6398 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
6399 CHECK(!owner->result_ok);
6400 return DecodeError_clone(&*owner->contents.err);
6402 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(uint64_t owner) {
6403 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(owner);
6404 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6405 *ret_copy = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner_conv);
6406 uint64_t ret_ref = tag_ptr(ret_copy, true);
6410 static inline struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
6411 LDKChannelConfig ret = *owner->contents.result;
6412 ret.is_owned = false;
6415 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_get_ok(uint64_t owner) {
6416 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
6417 LDKChannelConfig ret_var = CResult_ChannelConfigDecodeErrorZ_get_ok(owner_conv);
6418 uint64_t ret_ref = 0;
6419 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6420 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6424 static inline struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
6425 CHECK(!owner->result_ok);
6426 return DecodeError_clone(&*owner->contents.err);
6428 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_err"))) TS_CResult_ChannelConfigDecodeErrorZ_get_err(uint64_t owner) {
6429 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
6430 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6431 *ret_copy = CResult_ChannelConfigDecodeErrorZ_get_err(owner_conv);
6432 uint64_t ret_ref = tag_ptr(ret_copy, true);
6436 uint32_t __attribute__((export_name("TS_LDKCOption_APIErrorZ_ty_from_ptr"))) TS_LDKCOption_APIErrorZ_ty_from_ptr(uint64_t ptr) {
6437 LDKCOption_APIErrorZ *obj = (LDKCOption_APIErrorZ*)untag_ptr(ptr);
6439 case LDKCOption_APIErrorZ_Some: return 0;
6440 case LDKCOption_APIErrorZ_None: return 1;
6444 uint64_t __attribute__((export_name("TS_LDKCOption_APIErrorZ_Some_get_some"))) TS_LDKCOption_APIErrorZ_Some_get_some(uint64_t ptr) {
6445 LDKCOption_APIErrorZ *obj = (LDKCOption_APIErrorZ*)untag_ptr(ptr);
6446 assert(obj->tag == LDKCOption_APIErrorZ_Some);
6447 uint64_t some_ref = tag_ptr(&obj->some, false);
6450 static inline struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner){
6451 CHECK(owner->result_ok);
6452 return COption_APIErrorZ_clone(&*owner->contents.result);
6454 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(uint64_t owner) {
6455 LDKCResult_COption_APIErrorZDecodeErrorZ* owner_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(owner);
6456 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
6457 *ret_copy = CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner_conv);
6458 uint64_t ret_ref = tag_ptr(ret_copy, true);
6462 static inline struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner){
6463 CHECK(!owner->result_ok);
6464 return DecodeError_clone(&*owner->contents.err);
6466 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_get_err"))) TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(uint64_t owner) {
6467 LDKCResult_COption_APIErrorZDecodeErrorZ* owner_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(owner);
6468 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6469 *ret_copy = CResult_COption_APIErrorZDecodeErrorZ_get_err(owner_conv);
6470 uint64_t ret_ref = tag_ptr(ret_copy, true);
6474 static inline struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner){
6475 LDKUntrustedString ret = *owner->contents.result;
6476 ret.is_owned = false;
6479 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_get_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_get_ok(uint64_t owner) {
6480 LDKCResult_UntrustedStringDecodeErrorZ* owner_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(owner);
6481 LDKUntrustedString ret_var = CResult_UntrustedStringDecodeErrorZ_get_ok(owner_conv);
6482 uint64_t ret_ref = 0;
6483 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6484 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6488 static inline struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner){
6489 CHECK(!owner->result_ok);
6490 return DecodeError_clone(&*owner->contents.err);
6492 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_get_err"))) TS_CResult_UntrustedStringDecodeErrorZ_get_err(uint64_t owner) {
6493 LDKCResult_UntrustedStringDecodeErrorZ* owner_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(owner);
6494 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6495 *ret_copy = CResult_UntrustedStringDecodeErrorZ_get_err(owner_conv);
6496 uint64_t ret_ref = tag_ptr(ret_copy, true);
6500 static inline struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
6501 LDKOutPoint ret = *owner->contents.result;
6502 ret.is_owned = false;
6505 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_ok"))) TS_CResult_OutPointDecodeErrorZ_get_ok(uint64_t owner) {
6506 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
6507 LDKOutPoint ret_var = CResult_OutPointDecodeErrorZ_get_ok(owner_conv);
6508 uint64_t ret_ref = 0;
6509 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6510 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6514 static inline struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
6515 CHECK(!owner->result_ok);
6516 return DecodeError_clone(&*owner->contents.err);
6518 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_err"))) TS_CResult_OutPointDecodeErrorZ_get_err(uint64_t owner) {
6519 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
6520 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6521 *ret_copy = CResult_OutPointDecodeErrorZ_get_err(owner_conv);
6522 uint64_t ret_ref = tag_ptr(ret_copy, true);
6526 typedef struct LDKType_JCalls {
6527 atomic_size_t refcnt;
6528 uint32_t instance_ptr;
6530 static void LDKType_JCalls_free(void* this_arg) {
6531 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6532 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6536 uint16_t type_id_LDKType_jcall(const void* this_arg) {
6537 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6538 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 35, 0, 0, 0, 0, 0, 0);
6540 LDKStr debug_str_LDKType_jcall(const void* this_arg) {
6541 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6542 jstring ret = (jstring)js_invoke_function_uuuuuu(j_calls->instance_ptr, 36, 0, 0, 0, 0, 0, 0);
6543 LDKStr ret_conv = str_ref_to_owned_c(ret);
6546 LDKCVec_u8Z write_LDKType_jcall(const void* this_arg) {
6547 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6548 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 37, 0, 0, 0, 0, 0, 0);
6549 LDKCVec_u8Z ret_ref;
6550 ret_ref.datalen = ret->arr_len;
6551 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6552 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6555 static void LDKType_JCalls_cloned(LDKType* new_obj) {
6556 LDKType_JCalls *j_calls = (LDKType_JCalls*) new_obj->this_arg;
6557 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6559 static inline LDKType LDKType_init (JSValue o) {
6560 LDKType_JCalls *calls = MALLOC(sizeof(LDKType_JCalls), "LDKType_JCalls");
6561 atomic_init(&calls->refcnt, 1);
6562 calls->instance_ptr = o;
6565 .this_arg = (void*) calls,
6566 .type_id = type_id_LDKType_jcall,
6567 .debug_str = debug_str_LDKType_jcall,
6568 .write = write_LDKType_jcall,
6569 .cloned = LDKType_JCalls_cloned,
6570 .free = LDKType_JCalls_free,
6574 uint64_t __attribute__((export_name("TS_LDKType_new"))) TS_LDKType_new(JSValue o) {
6575 LDKType *res_ptr = MALLOC(sizeof(LDKType), "LDKType");
6576 *res_ptr = LDKType_init(o);
6577 return tag_ptr(res_ptr, true);
6579 int16_t __attribute__((export_name("TS_Type_type_id"))) TS_Type_type_id(uint64_t this_arg) {
6580 void* this_arg_ptr = untag_ptr(this_arg);
6581 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6582 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6583 int16_t ret_conv = (this_arg_conv->type_id)(this_arg_conv->this_arg);
6587 jstring __attribute__((export_name("TS_Type_debug_str"))) TS_Type_debug_str(uint64_t this_arg) {
6588 void* this_arg_ptr = untag_ptr(this_arg);
6589 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6590 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6591 LDKStr ret_str = (this_arg_conv->debug_str)(this_arg_conv->this_arg);
6592 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6597 int8_tArray __attribute__((export_name("TS_Type_write"))) TS_Type_write(uint64_t this_arg) {
6598 void* this_arg_ptr = untag_ptr(this_arg);
6599 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6600 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6601 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
6602 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6603 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6604 CVec_u8Z_free(ret_var);
6608 uint32_t __attribute__((export_name("TS_LDKCOption_TypeZ_ty_from_ptr"))) TS_LDKCOption_TypeZ_ty_from_ptr(uint64_t ptr) {
6609 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
6611 case LDKCOption_TypeZ_Some: return 0;
6612 case LDKCOption_TypeZ_None: return 1;
6616 uint64_t __attribute__((export_name("TS_LDKCOption_TypeZ_Some_get_some"))) TS_LDKCOption_TypeZ_Some_get_some(uint64_t ptr) {
6617 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
6618 assert(obj->tag == LDKCOption_TypeZ_Some);
6619 LDKType* some_ret = MALLOC(sizeof(LDKType), "LDKType");
6620 *some_ret = Type_clone(&obj->some);
6621 return tag_ptr(some_ret, true);
6623 static inline struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
6624 CHECK(owner->result_ok);
6625 return COption_TypeZ_clone(&*owner->contents.result);
6627 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_get_ok(uint64_t owner) {
6628 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
6629 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
6630 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_ok(owner_conv);
6631 uint64_t ret_ref = tag_ptr(ret_copy, true);
6635 static inline struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
6636 CHECK(!owner->result_ok);
6637 return DecodeError_clone(&*owner->contents.err);
6639 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_err"))) TS_CResult_COption_TypeZDecodeErrorZ_get_err(uint64_t owner) {
6640 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
6641 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6642 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_err(owner_conv);
6643 uint64_t ret_ref = tag_ptr(ret_copy, true);
6647 uint32_t __attribute__((export_name("TS_LDKPaymentError_ty_from_ptr"))) TS_LDKPaymentError_ty_from_ptr(uint64_t ptr) {
6648 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
6650 case LDKPaymentError_Invoice: return 0;
6651 case LDKPaymentError_Sending: return 1;
6655 jstring __attribute__((export_name("TS_LDKPaymentError_Invoice_get_invoice"))) TS_LDKPaymentError_Invoice_get_invoice(uint64_t ptr) {
6656 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
6657 assert(obj->tag == LDKPaymentError_Invoice);
6658 LDKStr invoice_str = obj->invoice;
6659 jstring invoice_conv = str_ref_to_ts(invoice_str.chars, invoice_str.len);
6660 return invoice_conv;
6662 uint32_t __attribute__((export_name("TS_LDKPaymentError_Sending_get_sending"))) TS_LDKPaymentError_Sending_get_sending(uint64_t ptr) {
6663 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
6664 assert(obj->tag == LDKPaymentError_Sending);
6665 uint32_t sending_conv = LDKRetryableSendFailure_to_js(obj->sending);
6666 return sending_conv;
6668 static inline struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
6669 CHECK(owner->result_ok);
6670 return ThirtyTwoBytes_clone(&*owner->contents.result);
6672 int8_tArray __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_ok"))) TS_CResult_PaymentIdPaymentErrorZ_get_ok(uint64_t owner) {
6673 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(owner);
6674 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6675 memcpy(ret_arr->elems, CResult_PaymentIdPaymentErrorZ_get_ok(owner_conv).data, 32);
6679 static inline struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
6680 CHECK(!owner->result_ok);
6681 return PaymentError_clone(&*owner->contents.err);
6683 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_err"))) TS_CResult_PaymentIdPaymentErrorZ_get_err(uint64_t owner) {
6684 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(owner);
6685 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
6686 *ret_copy = CResult_PaymentIdPaymentErrorZ_get_err(owner_conv);
6687 uint64_t ret_ref = tag_ptr(ret_copy, true);
6691 static inline void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
6692 CHECK(owner->result_ok);
6693 return *owner->contents.result;
6695 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_ok"))) TS_CResult_NonePaymentErrorZ_get_ok(uint64_t owner) {
6696 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
6697 CResult_NonePaymentErrorZ_get_ok(owner_conv);
6700 static inline struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
6701 CHECK(!owner->result_ok);
6702 return PaymentError_clone(&*owner->contents.err);
6704 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_err"))) TS_CResult_NonePaymentErrorZ_get_err(uint64_t owner) {
6705 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
6706 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
6707 *ret_copy = CResult_NonePaymentErrorZ_get_err(owner_conv);
6708 uint64_t ret_ref = tag_ptr(ret_copy, true);
6712 static inline struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner){
6713 CHECK(owner->result_ok);
6714 return *owner->contents.result;
6716 jstring __attribute__((export_name("TS_CResult_StringErrorZ_get_ok"))) TS_CResult_StringErrorZ_get_ok(uint64_t owner) {
6717 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)untag_ptr(owner);
6718 LDKStr ret_str = CResult_StringErrorZ_get_ok(owner_conv);
6719 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6723 static inline enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner){
6724 CHECK(!owner->result_ok);
6725 return *owner->contents.err;
6727 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_get_err"))) TS_CResult_StringErrorZ_get_err(uint64_t owner) {
6728 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)untag_ptr(owner);
6729 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_StringErrorZ_get_err(owner_conv));
6733 static inline struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6734 LDKChannelMonitorUpdate ret = *owner->contents.result;
6735 ret.is_owned = false;
6738 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6739 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6740 LDKChannelMonitorUpdate ret_var = CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner_conv);
6741 uint64_t ret_ref = 0;
6742 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6743 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6747 static inline struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6748 CHECK(!owner->result_ok);
6749 return DecodeError_clone(&*owner->contents.err);
6751 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(uint64_t owner) {
6752 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6753 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6754 *ret_copy = CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner_conv);
6755 uint64_t ret_ref = tag_ptr(ret_copy, true);
6759 uint32_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_ty_from_ptr"))) TS_LDKCOption_MonitorEventZ_ty_from_ptr(uint64_t ptr) {
6760 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6762 case LDKCOption_MonitorEventZ_Some: return 0;
6763 case LDKCOption_MonitorEventZ_None: return 1;
6767 uint64_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_Some_get_some"))) TS_LDKCOption_MonitorEventZ_Some_get_some(uint64_t ptr) {
6768 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6769 assert(obj->tag == LDKCOption_MonitorEventZ_Some);
6770 uint64_t some_ref = tag_ptr(&obj->some, false);
6773 static inline struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6774 CHECK(owner->result_ok);
6775 return COption_MonitorEventZ_clone(&*owner->contents.result);
6777 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint64_t owner) {
6778 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6779 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
6780 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner_conv);
6781 uint64_t ret_ref = tag_ptr(ret_copy, true);
6785 static inline struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6786 CHECK(!owner->result_ok);
6787 return DecodeError_clone(&*owner->contents.err);
6789 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(uint64_t owner) {
6790 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6791 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6792 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner_conv);
6793 uint64_t ret_ref = tag_ptr(ret_copy, true);
6797 static inline struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6798 LDKHTLCUpdate ret = *owner->contents.result;
6799 ret.is_owned = false;
6802 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6803 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6804 LDKHTLCUpdate ret_var = CResult_HTLCUpdateDecodeErrorZ_get_ok(owner_conv);
6805 uint64_t ret_ref = 0;
6806 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6807 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6811 static inline struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6812 CHECK(!owner->result_ok);
6813 return DecodeError_clone(&*owner->contents.err);
6815 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_err(uint64_t owner) {
6816 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6817 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6818 *ret_copy = CResult_HTLCUpdateDecodeErrorZ_get_err(owner_conv);
6819 uint64_t ret_ref = tag_ptr(ret_copy, true);
6823 static inline struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6824 LDKOutPoint ret = owner->a;
6825 ret.is_owned = false;
6828 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_a"))) TS_C2Tuple_OutPointScriptZ_get_a(uint64_t owner) {
6829 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(owner);
6830 LDKOutPoint ret_var = C2Tuple_OutPointScriptZ_get_a(owner_conv);
6831 uint64_t ret_ref = 0;
6832 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6833 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6837 static inline struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6838 return CVec_u8Z_clone(&owner->b);
6840 int8_tArray __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_b"))) TS_C2Tuple_OutPointScriptZ_get_b(uint64_t owner) {
6841 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(owner);
6842 LDKCVec_u8Z ret_var = C2Tuple_OutPointScriptZ_get_b(owner_conv);
6843 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6844 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6845 CVec_u8Z_free(ret_var);
6849 static inline uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6852 int32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_a"))) TS_C2Tuple_u32ScriptZ_get_a(uint64_t owner) {
6853 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(owner);
6854 int32_t ret_conv = C2Tuple_u32ScriptZ_get_a(owner_conv);
6858 static inline struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6859 return CVec_u8Z_clone(&owner->b);
6861 int8_tArray __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_b"))) TS_C2Tuple_u32ScriptZ_get_b(uint64_t owner) {
6862 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(owner);
6863 LDKCVec_u8Z ret_var = C2Tuple_u32ScriptZ_get_b(owner_conv);
6864 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6865 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6866 CVec_u8Z_free(ret_var);
6870 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
6871 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
6872 for (size_t i = 0; i < ret.datalen; i++) {
6873 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
6877 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6878 return ThirtyTwoBytes_clone(&owner->a);
6880 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint64_t owner) {
6881 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(owner);
6882 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6883 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner_conv).data, 32);
6887 static inline struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6888 return CVec_C2Tuple_u32ScriptZZ_clone(&owner->b);
6890 uint64_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint64_t owner) {
6891 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(owner);
6892 LDKCVec_C2Tuple_u32ScriptZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner_conv);
6893 uint64_tArray ret_arr = NULL;
6894 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6895 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6896 for (size_t v = 0; v < ret_var.datalen; v++) {
6897 LDKC2Tuple_u32ScriptZ* ret_conv_21_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
6898 *ret_conv_21_conv = ret_var.data[v];
6899 ret_arr_ptr[v] = tag_ptr(ret_conv_21_conv, true);
6906 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
6907 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 };
6908 for (size_t i = 0; i < ret.datalen; i++) {
6909 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(&orig->data[i]);
6913 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
6914 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
6915 for (size_t i = 0; i < ret.datalen; i++) {
6916 ret.data[i] = Event_clone(&orig->data[i]);
6920 static inline uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6923 int32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_a"))) TS_C2Tuple_u32TxOutZ_get_a(uint64_t owner) {
6924 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6925 int32_t ret_conv = C2Tuple_u32TxOutZ_get_a(owner_conv);
6929 static inline struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6930 return TxOut_clone(&owner->b);
6932 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_b"))) TS_C2Tuple_u32TxOutZ_get_b(uint64_t owner) {
6933 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6934 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6935 *ret_ref = C2Tuple_u32TxOutZ_get_b(owner_conv);
6936 return tag_ptr(ret_ref, true);
6939 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
6940 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
6941 for (size_t i = 0; i < ret.datalen; i++) {
6942 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
6946 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6947 return ThirtyTwoBytes_clone(&owner->a);
6949 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint64_t owner) {
6950 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6951 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6952 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner_conv).data, 32);
6956 static inline struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6957 return CVec_C2Tuple_u32TxOutZZ_clone(&owner->b);
6959 uint64_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint64_t owner) {
6960 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6961 LDKCVec_C2Tuple_u32TxOutZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner_conv);
6962 uint64_tArray ret_arr = NULL;
6963 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6964 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6965 for (size_t u = 0; u < ret_var.datalen; u++) {
6966 LDKC2Tuple_u32TxOutZ* ret_conv_20_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
6967 *ret_conv_20_conv = ret_var.data[u];
6968 ret_arr_ptr[u] = tag_ptr(ret_conv_20_conv, true);
6975 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
6976 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 };
6977 for (size_t i = 0; i < ret.datalen; i++) {
6978 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
6982 uint32_t __attribute__((export_name("TS_LDKBalance_ty_from_ptr"))) TS_LDKBalance_ty_from_ptr(uint64_t ptr) {
6983 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6985 case LDKBalance_ClaimableOnChannelClose: return 0;
6986 case LDKBalance_ClaimableAwaitingConfirmations: return 1;
6987 case LDKBalance_ContentiousClaimable: return 2;
6988 case LDKBalance_MaybeTimeoutClaimableHTLC: return 3;
6989 case LDKBalance_MaybePreimageClaimableHTLC: return 4;
6990 case LDKBalance_CounterpartyRevokedOutputClaimable: return 5;
6994 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(uint64_t ptr) {
6995 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6996 assert(obj->tag == LDKBalance_ClaimableOnChannelClose);
6997 int64_t claimable_amount_satoshis_conv = obj->claimable_on_channel_close.claimable_amount_satoshis;
6998 return claimable_amount_satoshis_conv;
7000 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(uint64_t ptr) {
7001 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7002 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
7003 int64_t claimable_amount_satoshis_conv = obj->claimable_awaiting_confirmations.claimable_amount_satoshis;
7004 return claimable_amount_satoshis_conv;
7006 int32_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(uint64_t ptr) {
7007 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7008 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
7009 int32_t confirmation_height_conv = obj->claimable_awaiting_confirmations.confirmation_height;
7010 return confirmation_height_conv;
7012 int64_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(uint64_t ptr) {
7013 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7014 assert(obj->tag == LDKBalance_ContentiousClaimable);
7015 int64_t claimable_amount_satoshis_conv = obj->contentious_claimable.claimable_amount_satoshis;
7016 return claimable_amount_satoshis_conv;
7018 int32_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_timeout_height"))) TS_LDKBalance_ContentiousClaimable_get_timeout_height(uint64_t ptr) {
7019 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7020 assert(obj->tag == LDKBalance_ContentiousClaimable);
7021 int32_t timeout_height_conv = obj->contentious_claimable.timeout_height;
7022 return timeout_height_conv;
7024 int64_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_amount_satoshis(uint64_t ptr) {
7025 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7026 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
7027 int64_t claimable_amount_satoshis_conv = obj->maybe_timeout_claimable_htlc.claimable_amount_satoshis;
7028 return claimable_amount_satoshis_conv;
7030 int32_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(uint64_t ptr) {
7031 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7032 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
7033 int32_t claimable_height_conv = obj->maybe_timeout_claimable_htlc.claimable_height;
7034 return claimable_height_conv;
7036 int64_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_claimable_amount_satoshis(uint64_t ptr) {
7037 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7038 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
7039 int64_t claimable_amount_satoshis_conv = obj->maybe_preimage_claimable_htlc.claimable_amount_satoshis;
7040 return claimable_amount_satoshis_conv;
7042 int32_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(uint64_t ptr) {
7043 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7044 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
7045 int32_t expiry_height_conv = obj->maybe_preimage_claimable_htlc.expiry_height;
7046 return expiry_height_conv;
7048 int64_t __attribute__((export_name("TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_claimable_amount_satoshis(uint64_t ptr) {
7049 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
7050 assert(obj->tag == LDKBalance_CounterpartyRevokedOutputClaimable);
7051 int64_t claimable_amount_satoshis_conv = obj->counterparty_revoked_output_claimable.claimable_amount_satoshis;
7052 return claimable_amount_satoshis_conv;
7054 static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
7055 LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
7056 for (size_t i = 0; i < ret.datalen; i++) {
7057 ret.data[i] = Balance_clone(&orig->data[i]);
7061 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
7062 return ThirtyTwoBytes_clone(&owner->a);
7064 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_a"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_a(uint64_t owner) {
7065 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(owner);
7066 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
7067 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelMonitorZ_get_a(owner_conv).data, 32);
7071 static inline struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
7072 LDKChannelMonitor ret = owner->b;
7073 ret.is_owned = false;
7076 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_b"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_b(uint64_t owner) {
7077 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(owner);
7078 LDKChannelMonitor ret_var = C2Tuple_BlockHashChannelMonitorZ_get_b(owner_conv);
7079 uint64_t ret_ref = 0;
7080 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7081 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7085 static inline struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
7086 CHECK(owner->result_ok);
7087 return C2Tuple_BlockHashChannelMonitorZ_clone(&*owner->contents.result);
7089 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint64_t owner) {
7090 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
7091 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
7092 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner_conv);
7093 return tag_ptr(ret_conv, true);
7096 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
7097 CHECK(!owner->result_ok);
7098 return DecodeError_clone(&*owner->contents.err);
7100 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(uint64_t owner) {
7101 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
7102 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7103 *ret_copy = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner_conv);
7104 uint64_t ret_ref = tag_ptr(ret_copy, true);
7108 static inline struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
7111 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_a"))) TS_C2Tuple_PublicKeyTypeZ_get_a(uint64_t owner) {
7112 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
7113 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
7114 memcpy(ret_arr->elems, C2Tuple_PublicKeyTypeZ_get_a(owner_conv).compressed_form, 33);
7118 static inline struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
7119 return Type_clone(&owner->b);
7121 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_b"))) TS_C2Tuple_PublicKeyTypeZ_get_b(uint64_t owner) {
7122 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
7123 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
7124 *ret_ret = C2Tuple_PublicKeyTypeZ_get_b(owner_conv);
7125 return tag_ptr(ret_ret, true);
7128 static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
7129 LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
7130 for (size_t i = 0; i < ret.datalen; i++) {
7131 ret.data[i] = C2Tuple_PublicKeyTypeZ_clone(&orig->data[i]);
7135 typedef struct LDKCustomOnionMessageContents_JCalls {
7136 atomic_size_t refcnt;
7137 uint32_t instance_ptr;
7138 } LDKCustomOnionMessageContents_JCalls;
7139 static void LDKCustomOnionMessageContents_JCalls_free(void* this_arg) {
7140 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
7141 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
7145 uint64_t tlv_type_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
7146 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
7147 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 38, 0, 0, 0, 0, 0, 0);
7149 LDKCVec_u8Z write_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
7150 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
7151 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 39, 0, 0, 0, 0, 0, 0);
7152 LDKCVec_u8Z ret_ref;
7153 ret_ref.datalen = ret->arr_len;
7154 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
7155 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
7158 static void LDKCustomOnionMessageContents_JCalls_cloned(LDKCustomOnionMessageContents* new_obj) {
7159 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) new_obj->this_arg;
7160 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
7162 static inline LDKCustomOnionMessageContents LDKCustomOnionMessageContents_init (JSValue o) {
7163 LDKCustomOnionMessageContents_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageContents_JCalls), "LDKCustomOnionMessageContents_JCalls");
7164 atomic_init(&calls->refcnt, 1);
7165 calls->instance_ptr = o;
7167 LDKCustomOnionMessageContents ret = {
7168 .this_arg = (void*) calls,
7169 .tlv_type = tlv_type_LDKCustomOnionMessageContents_jcall,
7170 .write = write_LDKCustomOnionMessageContents_jcall,
7171 .cloned = LDKCustomOnionMessageContents_JCalls_cloned,
7172 .free = LDKCustomOnionMessageContents_JCalls_free,
7176 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageContents_new"))) TS_LDKCustomOnionMessageContents_new(JSValue o) {
7177 LDKCustomOnionMessageContents *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
7178 *res_ptr = LDKCustomOnionMessageContents_init(o);
7179 return tag_ptr(res_ptr, true);
7181 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_tlv_type"))) TS_CustomOnionMessageContents_tlv_type(uint64_t this_arg) {
7182 void* this_arg_ptr = untag_ptr(this_arg);
7183 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
7184 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
7185 int64_t ret_conv = (this_arg_conv->tlv_type)(this_arg_conv->this_arg);
7189 int8_tArray __attribute__((export_name("TS_CustomOnionMessageContents_write"))) TS_CustomOnionMessageContents_write(uint64_t this_arg) {
7190 void* this_arg_ptr = untag_ptr(this_arg);
7191 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
7192 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
7193 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
7194 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
7195 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
7196 CVec_u8Z_free(ret_var);
7200 uint32_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr"))) TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(uint64_t ptr) {
7201 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
7203 case LDKCOption_CustomOnionMessageContentsZ_Some: return 0;
7204 case LDKCOption_CustomOnionMessageContentsZ_None: return 1;
7208 uint64_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some"))) TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(uint64_t ptr) {
7209 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
7210 assert(obj->tag == LDKCOption_CustomOnionMessageContentsZ_Some);
7211 LDKCustomOnionMessageContents* some_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
7212 *some_ret = CustomOnionMessageContents_clone(&obj->some);
7213 return tag_ptr(some_ret, true);
7215 static inline struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
7216 CHECK(owner->result_ok);
7217 return COption_CustomOnionMessageContentsZ_clone(&*owner->contents.result);
7219 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(uint64_t owner) {
7220 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
7221 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
7222 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner_conv);
7223 uint64_t ret_ref = tag_ptr(ret_copy, true);
7227 static inline struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
7228 CHECK(!owner->result_ok);
7229 return DecodeError_clone(&*owner->contents.err);
7231 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(uint64_t owner) {
7232 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
7233 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7234 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner_conv);
7235 uint64_t ret_ref = tag_ptr(ret_copy, true);
7239 uint32_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_ty_from_ptr"))) TS_LDKCOption_NetAddressZ_ty_from_ptr(uint64_t ptr) {
7240 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)untag_ptr(ptr);
7242 case LDKCOption_NetAddressZ_Some: return 0;
7243 case LDKCOption_NetAddressZ_None: return 1;
7247 uint64_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_Some_get_some"))) TS_LDKCOption_NetAddressZ_Some_get_some(uint64_t ptr) {
7248 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)untag_ptr(ptr);
7249 assert(obj->tag == LDKCOption_NetAddressZ_Some);
7250 uint64_t some_ref = tag_ptr(&obj->some, false);
7253 static inline struct LDKPublicKey C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner){
7256 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_a"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(uint64_t owner) {
7257 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* owner_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(owner);
7258 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
7259 memcpy(ret_arr->elems, C2Tuple_PublicKeyCOption_NetAddressZZ_get_a(owner_conv).compressed_form, 33);
7263 static inline struct LDKCOption_NetAddressZ C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR owner){
7264 return COption_NetAddressZ_clone(&owner->b);
7266 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_b"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(uint64_t owner) {
7267 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* owner_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(owner);
7268 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
7269 *ret_copy = C2Tuple_PublicKeyCOption_NetAddressZZ_get_b(owner_conv);
7270 uint64_t ret_ref = tag_ptr(ret_copy, true);
7274 static inline LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_clone(const LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ *orig) {
7275 LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ clone bytes"), .datalen = orig->datalen };
7276 for (size_t i = 0; i < ret.datalen; i++) {
7277 ret.data[i] = C2Tuple_PublicKeyCOption_NetAddressZZ_clone(&orig->data[i]);
7281 static inline struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
7282 CHECK(owner->result_ok);
7283 return CVec_u8Z_clone(&*owner->contents.result);
7285 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint64_t owner) {
7286 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
7287 LDKCVec_u8Z ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner_conv);
7288 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
7289 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
7290 CVec_u8Z_free(ret_var);
7294 static inline struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
7295 LDKPeerHandleError ret = *owner->contents.err;
7296 ret.is_owned = false;
7299 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(uint64_t owner) {
7300 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
7301 LDKPeerHandleError ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner_conv);
7302 uint64_t ret_ref = 0;
7303 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7304 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7308 static inline void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
7309 CHECK(owner->result_ok);
7310 return *owner->contents.result;
7312 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_ok"))) TS_CResult_NonePeerHandleErrorZ_get_ok(uint64_t owner) {
7313 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
7314 CResult_NonePeerHandleErrorZ_get_ok(owner_conv);
7317 static inline struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
7318 LDKPeerHandleError ret = *owner->contents.err;
7319 ret.is_owned = false;
7322 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_err"))) TS_CResult_NonePeerHandleErrorZ_get_err(uint64_t owner) {
7323 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
7324 LDKPeerHandleError ret_var = CResult_NonePeerHandleErrorZ_get_err(owner_conv);
7325 uint64_t ret_ref = 0;
7326 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7327 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7331 static inline bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
7332 CHECK(owner->result_ok);
7333 return *owner->contents.result;
7335 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_ok"))) TS_CResult_boolPeerHandleErrorZ_get_ok(uint64_t owner) {
7336 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
7337 jboolean ret_conv = CResult_boolPeerHandleErrorZ_get_ok(owner_conv);
7341 static inline struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
7342 LDKPeerHandleError ret = *owner->contents.err;
7343 ret.is_owned = false;
7346 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_err"))) TS_CResult_boolPeerHandleErrorZ_get_err(uint64_t owner) {
7347 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
7348 LDKPeerHandleError ret_var = CResult_boolPeerHandleErrorZ_get_err(owner_conv);
7349 uint64_t ret_ref = 0;
7350 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7351 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7355 uint32_t __attribute__((export_name("TS_LDKSendError_ty_from_ptr"))) TS_LDKSendError_ty_from_ptr(uint64_t ptr) {
7356 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
7358 case LDKSendError_Secp256k1: return 0;
7359 case LDKSendError_TooBigPacket: return 1;
7360 case LDKSendError_TooFewBlindedHops: return 2;
7361 case LDKSendError_InvalidFirstHop: return 3;
7362 case LDKSendError_InvalidMessage: return 4;
7363 case LDKSendError_BufferFull: return 5;
7364 case LDKSendError_GetNodeIdFailed: return 6;
7365 case LDKSendError_BlindedPathAdvanceFailed: return 7;
7369 uint32_t __attribute__((export_name("TS_LDKSendError_Secp256k1_get_secp256k1"))) TS_LDKSendError_Secp256k1_get_secp256k1(uint64_t ptr) {
7370 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
7371 assert(obj->tag == LDKSendError_Secp256k1);
7372 uint32_t secp256k1_conv = LDKSecp256k1Error_to_js(obj->secp256k1);
7373 return secp256k1_conv;
7375 static inline void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
7376 CHECK(owner->result_ok);
7377 return *owner->contents.result;
7379 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_ok"))) TS_CResult_NoneSendErrorZ_get_ok(uint64_t owner) {
7380 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
7381 CResult_NoneSendErrorZ_get_ok(owner_conv);
7384 static inline struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
7385 CHECK(!owner->result_ok);
7386 return SendError_clone(&*owner->contents.err);
7388 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_err"))) TS_CResult_NoneSendErrorZ_get_err(uint64_t owner) {
7389 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
7390 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
7391 *ret_copy = CResult_NoneSendErrorZ_get_err(owner_conv);
7392 uint64_t ret_ref = tag_ptr(ret_copy, true);
7396 static inline struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
7397 LDKBlindedPath ret = *owner->contents.result;
7398 ret.is_owned = false;
7401 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_ok"))) TS_CResult_BlindedPathNoneZ_get_ok(uint64_t owner) {
7402 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
7403 LDKBlindedPath ret_var = CResult_BlindedPathNoneZ_get_ok(owner_conv);
7404 uint64_t ret_ref = 0;
7405 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7406 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7410 static inline void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
7411 CHECK(!owner->result_ok);
7412 return *owner->contents.err;
7414 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_err"))) TS_CResult_BlindedPathNoneZ_get_err(uint64_t owner) {
7415 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
7416 CResult_BlindedPathNoneZ_get_err(owner_conv);
7419 static inline struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
7420 LDKBlindedPath ret = *owner->contents.result;
7421 ret.is_owned = false;
7424 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_ok"))) TS_CResult_BlindedPathDecodeErrorZ_get_ok(uint64_t owner) {
7425 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
7426 LDKBlindedPath ret_var = CResult_BlindedPathDecodeErrorZ_get_ok(owner_conv);
7427 uint64_t ret_ref = 0;
7428 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7429 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7433 static inline struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
7434 CHECK(!owner->result_ok);
7435 return DecodeError_clone(&*owner->contents.err);
7437 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_err"))) TS_CResult_BlindedPathDecodeErrorZ_get_err(uint64_t owner) {
7438 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
7439 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7440 *ret_copy = CResult_BlindedPathDecodeErrorZ_get_err(owner_conv);
7441 uint64_t ret_ref = tag_ptr(ret_copy, true);
7445 static inline struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
7446 LDKBlindedHop ret = *owner->contents.result;
7447 ret.is_owned = false;
7450 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopDecodeErrorZ_get_ok(uint64_t owner) {
7451 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
7452 LDKBlindedHop ret_var = CResult_BlindedHopDecodeErrorZ_get_ok(owner_conv);
7453 uint64_t ret_ref = 0;
7454 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7455 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7459 static inline struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
7460 CHECK(!owner->result_ok);
7461 return DecodeError_clone(&*owner->contents.err);
7463 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_err"))) TS_CResult_BlindedHopDecodeErrorZ_get_err(uint64_t owner) {
7464 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
7465 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7466 *ret_copy = CResult_BlindedHopDecodeErrorZ_get_err(owner_conv);
7467 uint64_t ret_ref = tag_ptr(ret_copy, true);
7471 uint32_t __attribute__((export_name("TS_LDKGraphSyncError_ty_from_ptr"))) TS_LDKGraphSyncError_ty_from_ptr(uint64_t ptr) {
7472 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7474 case LDKGraphSyncError_DecodeError: return 0;
7475 case LDKGraphSyncError_LightningError: return 1;
7479 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_DecodeError_get_decode_error"))) TS_LDKGraphSyncError_DecodeError_get_decode_error(uint64_t ptr) {
7480 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7481 assert(obj->tag == LDKGraphSyncError_DecodeError);
7482 uint64_t decode_error_ref = tag_ptr(&obj->decode_error, false);
7483 return decode_error_ref;
7485 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_LightningError_get_lightning_error"))) TS_LDKGraphSyncError_LightningError_get_lightning_error(uint64_t ptr) {
7486 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7487 assert(obj->tag == LDKGraphSyncError_LightningError);
7488 LDKLightningError lightning_error_var = obj->lightning_error;
7489 uint64_t lightning_error_ref = 0;
7490 CHECK_INNER_FIELD_ACCESS_OR_NULL(lightning_error_var);
7491 lightning_error_ref = tag_ptr(lightning_error_var.inner, false);
7492 return lightning_error_ref;
7494 static inline uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
7495 CHECK(owner->result_ok);
7496 return *owner->contents.result;
7498 int32_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_ok"))) TS_CResult_u32GraphSyncErrorZ_get_ok(uint64_t owner) {
7499 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
7500 int32_t ret_conv = CResult_u32GraphSyncErrorZ_get_ok(owner_conv);
7504 static inline struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
7505 CHECK(!owner->result_ok);
7506 return GraphSyncError_clone(&*owner->contents.err);
7508 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_err"))) TS_CResult_u32GraphSyncErrorZ_get_err(uint64_t owner) {
7509 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
7510 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
7511 *ret_copy = CResult_u32GraphSyncErrorZ_get_err(owner_conv);
7512 uint64_t ret_ref = tag_ptr(ret_copy, true);
7516 static inline void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
7517 CHECK(owner->result_ok);
7518 return *owner->contents.result;
7520 void __attribute__((export_name("TS_CResult_NoneErrorZ_get_ok"))) TS_CResult_NoneErrorZ_get_ok(uint64_t owner) {
7521 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)untag_ptr(owner);
7522 CResult_NoneErrorZ_get_ok(owner_conv);
7525 static inline enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
7526 CHECK(!owner->result_ok);
7527 return *owner->contents.err;
7529 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_get_err"))) TS_CResult_NoneErrorZ_get_err(uint64_t owner) {
7530 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)untag_ptr(owner);
7531 uint32_t ret_conv = LDKIOError_to_js(CResult_NoneErrorZ_get_err(owner_conv));
7535 static inline struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7536 CHECK(owner->result_ok);
7537 return NetAddress_clone(&*owner->contents.result);
7539 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_ok"))) TS_CResult_NetAddressDecodeErrorZ_get_ok(uint64_t owner) {
7540 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(owner);
7541 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
7542 *ret_copy = CResult_NetAddressDecodeErrorZ_get_ok(owner_conv);
7543 uint64_t ret_ref = tag_ptr(ret_copy, true);
7547 static inline struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7548 CHECK(!owner->result_ok);
7549 return DecodeError_clone(&*owner->contents.err);
7551 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_err"))) TS_CResult_NetAddressDecodeErrorZ_get_err(uint64_t owner) {
7552 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(owner);
7553 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7554 *ret_copy = CResult_NetAddressDecodeErrorZ_get_err(owner_conv);
7555 uint64_t ret_ref = tag_ptr(ret_copy, true);
7559 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
7560 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
7561 for (size_t i = 0; i < ret.datalen; i++) {
7562 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
7566 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
7567 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
7568 for (size_t i = 0; i < ret.datalen; i++) {
7569 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
7573 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
7574 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
7575 for (size_t i = 0; i < ret.datalen; i++) {
7576 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
7580 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
7581 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
7582 for (size_t i = 0; i < ret.datalen; i++) {
7583 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
7587 static inline struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7588 LDKAcceptChannel ret = *owner->contents.result;
7589 ret.is_owned = false;
7592 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_get_ok(uint64_t owner) {
7593 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7594 LDKAcceptChannel ret_var = CResult_AcceptChannelDecodeErrorZ_get_ok(owner_conv);
7595 uint64_t ret_ref = 0;
7596 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7597 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7601 static inline struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7602 CHECK(!owner->result_ok);
7603 return DecodeError_clone(&*owner->contents.err);
7605 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_err"))) TS_CResult_AcceptChannelDecodeErrorZ_get_err(uint64_t owner) {
7606 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7607 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7608 *ret_copy = CResult_AcceptChannelDecodeErrorZ_get_err(owner_conv);
7609 uint64_t ret_ref = tag_ptr(ret_copy, true);
7613 static inline struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7614 LDKAnnouncementSignatures ret = *owner->contents.result;
7615 ret.is_owned = false;
7618 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint64_t owner) {
7619 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7620 LDKAnnouncementSignatures ret_var = CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner_conv);
7621 uint64_t ret_ref = 0;
7622 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7623 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7627 static inline struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7628 CHECK(!owner->result_ok);
7629 return DecodeError_clone(&*owner->contents.err);
7631 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(uint64_t owner) {
7632 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7633 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7634 *ret_copy = CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner_conv);
7635 uint64_t ret_ref = tag_ptr(ret_copy, true);
7639 static inline struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7640 LDKChannelReestablish ret = *owner->contents.result;
7641 ret.is_owned = false;
7644 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(uint64_t owner) {
7645 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7646 LDKChannelReestablish ret_var = CResult_ChannelReestablishDecodeErrorZ_get_ok(owner_conv);
7647 uint64_t ret_ref = 0;
7648 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7649 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7653 static inline struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7654 CHECK(!owner->result_ok);
7655 return DecodeError_clone(&*owner->contents.err);
7657 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_err(uint64_t owner) {
7658 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7659 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7660 *ret_copy = CResult_ChannelReestablishDecodeErrorZ_get_err(owner_conv);
7661 uint64_t ret_ref = tag_ptr(ret_copy, true);
7665 static inline struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7666 LDKClosingSigned ret = *owner->contents.result;
7667 ret.is_owned = false;
7670 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7671 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7672 LDKClosingSigned ret_var = CResult_ClosingSignedDecodeErrorZ_get_ok(owner_conv);
7673 uint64_t ret_ref = 0;
7674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7675 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7679 static inline struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7680 CHECK(!owner->result_ok);
7681 return DecodeError_clone(&*owner->contents.err);
7683 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedDecodeErrorZ_get_err(uint64_t owner) {
7684 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7685 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7686 *ret_copy = CResult_ClosingSignedDecodeErrorZ_get_err(owner_conv);
7687 uint64_t ret_ref = tag_ptr(ret_copy, true);
7691 static inline struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7692 LDKClosingSignedFeeRange ret = *owner->contents.result;
7693 ret.is_owned = false;
7696 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint64_t owner) {
7697 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7698 LDKClosingSignedFeeRange ret_var = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner_conv);
7699 uint64_t ret_ref = 0;
7700 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7701 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7705 static inline struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7706 CHECK(!owner->result_ok);
7707 return DecodeError_clone(&*owner->contents.err);
7709 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(uint64_t owner) {
7710 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7711 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7712 *ret_copy = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner_conv);
7713 uint64_t ret_ref = tag_ptr(ret_copy, true);
7717 static inline struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7718 LDKCommitmentSigned ret = *owner->contents.result;
7719 ret.is_owned = false;
7722 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(uint64_t owner) {
7723 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7724 LDKCommitmentSigned ret_var = CResult_CommitmentSignedDecodeErrorZ_get_ok(owner_conv);
7725 uint64_t ret_ref = 0;
7726 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7727 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7731 static inline struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7732 CHECK(!owner->result_ok);
7733 return DecodeError_clone(&*owner->contents.err);
7735 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_err(uint64_t owner) {
7736 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7737 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7738 *ret_copy = CResult_CommitmentSignedDecodeErrorZ_get_err(owner_conv);
7739 uint64_t ret_ref = tag_ptr(ret_copy, true);
7743 static inline struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7744 LDKFundingCreated ret = *owner->contents.result;
7745 ret.is_owned = false;
7748 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_get_ok(uint64_t owner) {
7749 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7750 LDKFundingCreated ret_var = CResult_FundingCreatedDecodeErrorZ_get_ok(owner_conv);
7751 uint64_t ret_ref = 0;
7752 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7753 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7757 static inline struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7758 CHECK(!owner->result_ok);
7759 return DecodeError_clone(&*owner->contents.err);
7761 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_err"))) TS_CResult_FundingCreatedDecodeErrorZ_get_err(uint64_t owner) {
7762 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7763 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7764 *ret_copy = CResult_FundingCreatedDecodeErrorZ_get_err(owner_conv);
7765 uint64_t ret_ref = tag_ptr(ret_copy, true);
7769 static inline struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7770 LDKFundingSigned ret = *owner->contents.result;
7771 ret.is_owned = false;
7774 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_ok"))) TS_CResult_FundingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7775 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7776 LDKFundingSigned ret_var = CResult_FundingSignedDecodeErrorZ_get_ok(owner_conv);
7777 uint64_t ret_ref = 0;
7778 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7779 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7783 static inline struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7784 CHECK(!owner->result_ok);
7785 return DecodeError_clone(&*owner->contents.err);
7787 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_err"))) TS_CResult_FundingSignedDecodeErrorZ_get_err(uint64_t owner) {
7788 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7789 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7790 *ret_copy = CResult_FundingSignedDecodeErrorZ_get_err(owner_conv);
7791 uint64_t ret_ref = tag_ptr(ret_copy, true);
7795 static inline struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7796 LDKChannelReady ret = *owner->contents.result;
7797 ret.is_owned = false;
7800 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_get_ok(uint64_t owner) {
7801 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7802 LDKChannelReady ret_var = CResult_ChannelReadyDecodeErrorZ_get_ok(owner_conv);
7803 uint64_t ret_ref = 0;
7804 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7805 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7809 static inline struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7810 CHECK(!owner->result_ok);
7811 return DecodeError_clone(&*owner->contents.err);
7813 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_err"))) TS_CResult_ChannelReadyDecodeErrorZ_get_err(uint64_t owner) {
7814 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7815 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7816 *ret_copy = CResult_ChannelReadyDecodeErrorZ_get_err(owner_conv);
7817 uint64_t ret_ref = tag_ptr(ret_copy, true);
7821 static inline struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7822 LDKInit ret = *owner->contents.result;
7823 ret.is_owned = false;
7826 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_ok"))) TS_CResult_InitDecodeErrorZ_get_ok(uint64_t owner) {
7827 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7828 LDKInit ret_var = CResult_InitDecodeErrorZ_get_ok(owner_conv);
7829 uint64_t ret_ref = 0;
7830 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7831 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7835 static inline struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7836 CHECK(!owner->result_ok);
7837 return DecodeError_clone(&*owner->contents.err);
7839 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_err"))) TS_CResult_InitDecodeErrorZ_get_err(uint64_t owner) {
7840 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7841 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7842 *ret_copy = CResult_InitDecodeErrorZ_get_err(owner_conv);
7843 uint64_t ret_ref = tag_ptr(ret_copy, true);
7847 static inline struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7848 LDKOpenChannel ret = *owner->contents.result;
7849 ret.is_owned = false;
7852 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_ok"))) TS_CResult_OpenChannelDecodeErrorZ_get_ok(uint64_t owner) {
7853 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7854 LDKOpenChannel ret_var = CResult_OpenChannelDecodeErrorZ_get_ok(owner_conv);
7855 uint64_t ret_ref = 0;
7856 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7857 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7861 static inline struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7862 CHECK(!owner->result_ok);
7863 return DecodeError_clone(&*owner->contents.err);
7865 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_err"))) TS_CResult_OpenChannelDecodeErrorZ_get_err(uint64_t owner) {
7866 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7867 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7868 *ret_copy = CResult_OpenChannelDecodeErrorZ_get_err(owner_conv);
7869 uint64_t ret_ref = tag_ptr(ret_copy, true);
7873 static inline struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7874 LDKRevokeAndACK ret = *owner->contents.result;
7875 ret.is_owned = false;
7878 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(uint64_t owner) {
7879 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7880 LDKRevokeAndACK ret_var = CResult_RevokeAndACKDecodeErrorZ_get_ok(owner_conv);
7881 uint64_t ret_ref = 0;
7882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7883 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7887 static inline struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7888 CHECK(!owner->result_ok);
7889 return DecodeError_clone(&*owner->contents.err);
7891 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_err(uint64_t owner) {
7892 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7893 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7894 *ret_copy = CResult_RevokeAndACKDecodeErrorZ_get_err(owner_conv);
7895 uint64_t ret_ref = tag_ptr(ret_copy, true);
7899 static inline struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7900 LDKShutdown ret = *owner->contents.result;
7901 ret.is_owned = false;
7904 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_ok"))) TS_CResult_ShutdownDecodeErrorZ_get_ok(uint64_t owner) {
7905 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7906 LDKShutdown ret_var = CResult_ShutdownDecodeErrorZ_get_ok(owner_conv);
7907 uint64_t ret_ref = 0;
7908 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7909 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7913 static inline struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7914 CHECK(!owner->result_ok);
7915 return DecodeError_clone(&*owner->contents.err);
7917 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_err"))) TS_CResult_ShutdownDecodeErrorZ_get_err(uint64_t owner) {
7918 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7919 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7920 *ret_copy = CResult_ShutdownDecodeErrorZ_get_err(owner_conv);
7921 uint64_t ret_ref = tag_ptr(ret_copy, true);
7925 static inline struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7926 LDKUpdateFailHTLC ret = *owner->contents.result;
7927 ret.is_owned = false;
7930 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7931 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
7932 LDKUpdateFailHTLC ret_var = CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner_conv);
7933 uint64_t ret_ref = 0;
7934 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7935 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7939 static inline struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7940 CHECK(!owner->result_ok);
7941 return DecodeError_clone(&*owner->contents.err);
7943 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(uint64_t owner) {
7944 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
7945 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7946 *ret_copy = CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner_conv);
7947 uint64_t ret_ref = tag_ptr(ret_copy, true);
7951 static inline struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7952 LDKUpdateFailMalformedHTLC ret = *owner->contents.result;
7953 ret.is_owned = false;
7956 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint64_t owner) {
7957 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
7958 LDKUpdateFailMalformedHTLC ret_var = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner_conv);
7959 uint64_t ret_ref = 0;
7960 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7961 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7965 static inline struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7966 CHECK(!owner->result_ok);
7967 return DecodeError_clone(&*owner->contents.err);
7969 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(uint64_t owner) {
7970 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
7971 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7972 *ret_copy = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner_conv);
7973 uint64_t ret_ref = tag_ptr(ret_copy, true);
7977 static inline struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7978 LDKUpdateFee ret = *owner->contents.result;
7979 ret.is_owned = false;
7982 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_get_ok(uint64_t owner) {
7983 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
7984 LDKUpdateFee ret_var = CResult_UpdateFeeDecodeErrorZ_get_ok(owner_conv);
7985 uint64_t ret_ref = 0;
7986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7991 static inline struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7992 CHECK(!owner->result_ok);
7993 return DecodeError_clone(&*owner->contents.err);
7995 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_err"))) TS_CResult_UpdateFeeDecodeErrorZ_get_err(uint64_t owner) {
7996 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
7997 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7998 *ret_copy = CResult_UpdateFeeDecodeErrorZ_get_err(owner_conv);
7999 uint64_t ret_ref = tag_ptr(ret_copy, true);
8003 static inline struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
8004 LDKUpdateFulfillHTLC ret = *owner->contents.result;
8005 ret.is_owned = false;
8008 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8009 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
8010 LDKUpdateFulfillHTLC ret_var = CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner_conv);
8011 uint64_t ret_ref = 0;
8012 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8013 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8017 static inline struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
8018 CHECK(!owner->result_ok);
8019 return DecodeError_clone(&*owner->contents.err);
8021 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(uint64_t owner) {
8022 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
8023 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8024 *ret_copy = CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner_conv);
8025 uint64_t ret_ref = tag_ptr(ret_copy, true);
8029 static inline struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
8030 LDKUpdateAddHTLC ret = *owner->contents.result;
8031 ret.is_owned = false;
8034 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8035 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
8036 LDKUpdateAddHTLC ret_var = CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner_conv);
8037 uint64_t ret_ref = 0;
8038 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8039 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8043 static inline struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
8044 CHECK(!owner->result_ok);
8045 return DecodeError_clone(&*owner->contents.err);
8047 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(uint64_t owner) {
8048 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
8049 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8050 *ret_copy = CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner_conv);
8051 uint64_t ret_ref = tag_ptr(ret_copy, true);
8055 static inline struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
8056 LDKOnionMessage ret = *owner->contents.result;
8057 ret.is_owned = false;
8060 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_ok"))) TS_CResult_OnionMessageDecodeErrorZ_get_ok(uint64_t owner) {
8061 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
8062 LDKOnionMessage ret_var = CResult_OnionMessageDecodeErrorZ_get_ok(owner_conv);
8063 uint64_t ret_ref = 0;
8064 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8065 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8069 static inline struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
8070 CHECK(!owner->result_ok);
8071 return DecodeError_clone(&*owner->contents.err);
8073 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_err"))) TS_CResult_OnionMessageDecodeErrorZ_get_err(uint64_t owner) {
8074 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
8075 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8076 *ret_copy = CResult_OnionMessageDecodeErrorZ_get_err(owner_conv);
8077 uint64_t ret_ref = tag_ptr(ret_copy, true);
8081 static inline struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
8082 LDKPing ret = *owner->contents.result;
8083 ret.is_owned = false;
8086 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_ok"))) TS_CResult_PingDecodeErrorZ_get_ok(uint64_t owner) {
8087 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
8088 LDKPing ret_var = CResult_PingDecodeErrorZ_get_ok(owner_conv);
8089 uint64_t ret_ref = 0;
8090 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8091 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8095 static inline struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
8096 CHECK(!owner->result_ok);
8097 return DecodeError_clone(&*owner->contents.err);
8099 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_err"))) TS_CResult_PingDecodeErrorZ_get_err(uint64_t owner) {
8100 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
8101 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8102 *ret_copy = CResult_PingDecodeErrorZ_get_err(owner_conv);
8103 uint64_t ret_ref = tag_ptr(ret_copy, true);
8107 static inline struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
8108 LDKPong ret = *owner->contents.result;
8109 ret.is_owned = false;
8112 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_ok"))) TS_CResult_PongDecodeErrorZ_get_ok(uint64_t owner) {
8113 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
8114 LDKPong ret_var = CResult_PongDecodeErrorZ_get_ok(owner_conv);
8115 uint64_t ret_ref = 0;
8116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8117 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8121 static inline struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
8122 CHECK(!owner->result_ok);
8123 return DecodeError_clone(&*owner->contents.err);
8125 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_err"))) TS_CResult_PongDecodeErrorZ_get_err(uint64_t owner) {
8126 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
8127 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8128 *ret_copy = CResult_PongDecodeErrorZ_get_err(owner_conv);
8129 uint64_t ret_ref = tag_ptr(ret_copy, true);
8133 static inline struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8134 LDKUnsignedChannelAnnouncement ret = *owner->contents.result;
8135 ret.is_owned = false;
8138 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8139 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8140 LDKUnsignedChannelAnnouncement ret_var = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
8141 uint64_t ret_ref = 0;
8142 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8143 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8147 static inline struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8148 CHECK(!owner->result_ok);
8149 return DecodeError_clone(&*owner->contents.err);
8151 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8152 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8153 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8154 *ret_copy = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
8155 uint64_t ret_ref = tag_ptr(ret_copy, true);
8159 static inline struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8160 LDKChannelAnnouncement ret = *owner->contents.result;
8161 ret.is_owned = false;
8164 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8165 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8166 LDKChannelAnnouncement ret_var = CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
8167 uint64_t ret_ref = 0;
8168 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8169 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8173 static inline struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8174 CHECK(!owner->result_ok);
8175 return DecodeError_clone(&*owner->contents.err);
8177 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8178 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8179 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8180 *ret_copy = CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
8181 uint64_t ret_ref = tag_ptr(ret_copy, true);
8185 static inline struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8186 LDKUnsignedChannelUpdate ret = *owner->contents.result;
8187 ret.is_owned = false;
8190 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
8191 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8192 LDKUnsignedChannelUpdate ret_var = CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner_conv);
8193 uint64_t ret_ref = 0;
8194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8195 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8199 static inline struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8200 CHECK(!owner->result_ok);
8201 return DecodeError_clone(&*owner->contents.err);
8203 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
8204 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8205 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8206 *ret_copy = CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner_conv);
8207 uint64_t ret_ref = tag_ptr(ret_copy, true);
8211 static inline struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8212 LDKChannelUpdate ret = *owner->contents.result;
8213 ret.is_owned = false;
8216 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
8217 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8218 LDKChannelUpdate ret_var = CResult_ChannelUpdateDecodeErrorZ_get_ok(owner_conv);
8219 uint64_t ret_ref = 0;
8220 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8221 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8225 static inline struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8226 CHECK(!owner->result_ok);
8227 return DecodeError_clone(&*owner->contents.err);
8229 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
8230 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8231 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8232 *ret_copy = CResult_ChannelUpdateDecodeErrorZ_get_err(owner_conv);
8233 uint64_t ret_ref = tag_ptr(ret_copy, true);
8237 static inline struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
8238 LDKErrorMessage ret = *owner->contents.result;
8239 ret.is_owned = false;
8242 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_get_ok(uint64_t owner) {
8243 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
8244 LDKErrorMessage ret_var = CResult_ErrorMessageDecodeErrorZ_get_ok(owner_conv);
8245 uint64_t ret_ref = 0;
8246 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8247 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8251 static inline struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
8252 CHECK(!owner->result_ok);
8253 return DecodeError_clone(&*owner->contents.err);
8255 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_err"))) TS_CResult_ErrorMessageDecodeErrorZ_get_err(uint64_t owner) {
8256 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
8257 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8258 *ret_copy = CResult_ErrorMessageDecodeErrorZ_get_err(owner_conv);
8259 uint64_t ret_ref = tag_ptr(ret_copy, true);
8263 static inline struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
8264 LDKWarningMessage ret = *owner->contents.result;
8265 ret.is_owned = false;
8268 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_ok"))) TS_CResult_WarningMessageDecodeErrorZ_get_ok(uint64_t owner) {
8269 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
8270 LDKWarningMessage ret_var = CResult_WarningMessageDecodeErrorZ_get_ok(owner_conv);
8271 uint64_t ret_ref = 0;
8272 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8273 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8277 static inline struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
8278 CHECK(!owner->result_ok);
8279 return DecodeError_clone(&*owner->contents.err);
8281 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_err"))) TS_CResult_WarningMessageDecodeErrorZ_get_err(uint64_t owner) {
8282 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
8283 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8284 *ret_copy = CResult_WarningMessageDecodeErrorZ_get_err(owner_conv);
8285 uint64_t ret_ref = tag_ptr(ret_copy, true);
8289 static inline struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8290 LDKUnsignedNodeAnnouncement ret = *owner->contents.result;
8291 ret.is_owned = false;
8294 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8295 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8296 LDKUnsignedNodeAnnouncement ret_var = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8297 uint64_t ret_ref = 0;
8298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8303 static inline struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8304 CHECK(!owner->result_ok);
8305 return DecodeError_clone(&*owner->contents.err);
8307 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8308 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8309 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8310 *ret_copy = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8311 uint64_t ret_ref = tag_ptr(ret_copy, true);
8315 static inline struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8316 LDKNodeAnnouncement ret = *owner->contents.result;
8317 ret.is_owned = false;
8320 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8321 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8322 LDKNodeAnnouncement ret_var = CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8323 uint64_t ret_ref = 0;
8324 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8325 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8329 static inline struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8330 CHECK(!owner->result_ok);
8331 return DecodeError_clone(&*owner->contents.err);
8333 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8334 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8335 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8336 *ret_copy = CResult_NodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8337 uint64_t ret_ref = tag_ptr(ret_copy, true);
8341 static inline struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8342 LDKQueryShortChannelIds ret = *owner->contents.result;
8343 ret.is_owned = false;
8346 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint64_t owner) {
8347 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
8348 LDKQueryShortChannelIds ret_var = CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner_conv);
8349 uint64_t ret_ref = 0;
8350 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8351 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8355 static inline struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8356 CHECK(!owner->result_ok);
8357 return DecodeError_clone(&*owner->contents.err);
8359 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(uint64_t owner) {
8360 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
8361 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8362 *ret_copy = CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner_conv);
8363 uint64_t ret_ref = tag_ptr(ret_copy, true);
8367 static inline struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8368 LDKReplyShortChannelIdsEnd ret = *owner->contents.result;
8369 ret.is_owned = false;
8372 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint64_t owner) {
8373 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
8374 LDKReplyShortChannelIdsEnd ret_var = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner_conv);
8375 uint64_t ret_ref = 0;
8376 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8377 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8381 static inline struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8382 CHECK(!owner->result_ok);
8383 return DecodeError_clone(&*owner->contents.err);
8385 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(uint64_t owner) {
8386 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
8387 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8388 *ret_copy = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner_conv);
8389 uint64_t ret_ref = tag_ptr(ret_copy, true);
8393 static inline struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8394 LDKQueryChannelRange ret = *owner->contents.result;
8395 ret.is_owned = false;
8398 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
8399 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
8400 LDKQueryChannelRange ret_var = CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner_conv);
8401 uint64_t ret_ref = 0;
8402 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8403 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8407 static inline struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8408 CHECK(!owner->result_ok);
8409 return DecodeError_clone(&*owner->contents.err);
8411 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
8412 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
8413 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8414 *ret_copy = CResult_QueryChannelRangeDecodeErrorZ_get_err(owner_conv);
8415 uint64_t ret_ref = tag_ptr(ret_copy, true);
8419 static inline struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8420 LDKReplyChannelRange ret = *owner->contents.result;
8421 ret.is_owned = false;
8424 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
8425 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
8426 LDKReplyChannelRange ret_var = CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner_conv);
8427 uint64_t ret_ref = 0;
8428 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8429 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8433 static inline struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8434 CHECK(!owner->result_ok);
8435 return DecodeError_clone(&*owner->contents.err);
8437 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
8438 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
8439 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8440 *ret_copy = CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner_conv);
8441 uint64_t ret_ref = tag_ptr(ret_copy, true);
8445 static inline struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8446 LDKGossipTimestampFilter ret = *owner->contents.result;
8447 ret.is_owned = false;
8450 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint64_t owner) {
8451 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
8452 LDKGossipTimestampFilter ret_var = CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner_conv);
8453 uint64_t ret_ref = 0;
8454 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8455 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8459 static inline struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8460 CHECK(!owner->result_ok);
8461 return DecodeError_clone(&*owner->contents.err);
8463 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(uint64_t owner) {
8464 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
8465 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8466 *ret_copy = CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner_conv);
8467 uint64_t ret_ref = tag_ptr(ret_copy, true);
8471 typedef struct LDKFilter_JCalls {
8472 atomic_size_t refcnt;
8473 uint32_t instance_ptr;
8475 static void LDKFilter_JCalls_free(void* this_arg) {
8476 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8477 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8481 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
8482 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8483 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
8484 memcpy(txid_arr->elems, *txid, 32);
8485 LDKu8slice script_pubkey_var = script_pubkey;
8486 int8_tArray script_pubkey_arr = init_int8_tArray(script_pubkey_var.datalen, __LINE__);
8487 memcpy(script_pubkey_arr->elems, script_pubkey_var.data, script_pubkey_var.datalen);
8488 js_invoke_function_uuuuuu(j_calls->instance_ptr, 40, (uint32_t)txid_arr, (uint32_t)script_pubkey_arr, 0, 0, 0, 0);
8490 void register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
8491 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8492 LDKWatchedOutput output_var = output;
8493 uint64_t output_ref = 0;
8494 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
8495 output_ref = tag_ptr(output_var.inner, output_var.is_owned);
8496 js_invoke_function_buuuuu(j_calls->instance_ptr, 41, output_ref, 0, 0, 0, 0, 0);
8498 static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
8499 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg;
8500 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8502 static inline LDKFilter LDKFilter_init (JSValue o) {
8503 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
8504 atomic_init(&calls->refcnt, 1);
8505 calls->instance_ptr = o;
8508 .this_arg = (void*) calls,
8509 .register_tx = register_tx_LDKFilter_jcall,
8510 .register_output = register_output_LDKFilter_jcall,
8511 .free = LDKFilter_JCalls_free,
8515 uint64_t __attribute__((export_name("TS_LDKFilter_new"))) TS_LDKFilter_new(JSValue o) {
8516 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
8517 *res_ptr = LDKFilter_init(o);
8518 return tag_ptr(res_ptr, true);
8520 void __attribute__((export_name("TS_Filter_register_tx"))) TS_Filter_register_tx(uint64_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
8521 void* this_arg_ptr = untag_ptr(this_arg);
8522 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8523 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8524 uint8_t txid_arr[32];
8525 CHECK(txid->arr_len == 32);
8526 memcpy(txid_arr, txid->elems, 32); FREE(txid);
8527 uint8_t (*txid_ref)[32] = &txid_arr;
8528 LDKu8slice script_pubkey_ref;
8529 script_pubkey_ref.datalen = script_pubkey->arr_len;
8530 script_pubkey_ref.data = script_pubkey->elems;
8531 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
8532 FREE(script_pubkey);
8535 void __attribute__((export_name("TS_Filter_register_output"))) TS_Filter_register_output(uint64_t this_arg, uint64_t output) {
8536 void* this_arg_ptr = untag_ptr(this_arg);
8537 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
8538 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8539 LDKWatchedOutput output_conv;
8540 output_conv.inner = untag_ptr(output);
8541 output_conv.is_owned = ptr_is_owned(output);
8542 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
8543 output_conv = WatchedOutput_clone(&output_conv);
8544 (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
8547 uint32_t __attribute__((export_name("TS_LDKCOption_FilterZ_ty_from_ptr"))) TS_LDKCOption_FilterZ_ty_from_ptr(uint64_t ptr) {
8548 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
8550 case LDKCOption_FilterZ_Some: return 0;
8551 case LDKCOption_FilterZ_None: return 1;
8555 uint64_t __attribute__((export_name("TS_LDKCOption_FilterZ_Some_get_some"))) TS_LDKCOption_FilterZ_Some_get_some(uint64_t ptr) {
8556 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
8557 assert(obj->tag == LDKCOption_FilterZ_Some);
8558 LDKFilter* some_ret = MALLOC(sizeof(LDKFilter), "LDKFilter");
8559 *some_ret = obj->some;
8560 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
8561 if ((*some_ret).free == LDKFilter_JCalls_free) {
8562 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8563 LDKFilter_JCalls_cloned(&(*some_ret));
8565 return tag_ptr(some_ret, true);
8567 static inline struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8568 LDKLockedChannelMonitor ret = *owner->contents.result;
8569 ret.is_owned = false;
8572 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_ok"))) TS_CResult_LockedChannelMonitorNoneZ_get_ok(uint64_t owner) {
8573 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
8574 LDKLockedChannelMonitor ret_var = CResult_LockedChannelMonitorNoneZ_get_ok(owner_conv);
8575 uint64_t ret_ref = 0;
8576 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8577 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8581 static inline void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8582 CHECK(!owner->result_ok);
8583 return *owner->contents.err;
8585 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_err"))) TS_CResult_LockedChannelMonitorNoneZ_get_err(uint64_t owner) {
8586 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
8587 CResult_LockedChannelMonitorNoneZ_get_err(owner_conv);
8590 static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
8591 LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
8592 for (size_t i = 0; i < ret.datalen; i++) {
8593 ret.data[i] = OutPoint_clone(&orig->data[i]);
8597 static inline LDKCVec_MonitorUpdateIdZ CVec_MonitorUpdateIdZ_clone(const LDKCVec_MonitorUpdateIdZ *orig) {
8598 LDKCVec_MonitorUpdateIdZ ret = { .data = MALLOC(sizeof(LDKMonitorUpdateId) * orig->datalen, "LDKCVec_MonitorUpdateIdZ clone bytes"), .datalen = orig->datalen };
8599 for (size_t i = 0; i < ret.datalen; i++) {
8600 ret.data[i] = MonitorUpdateId_clone(&orig->data[i]);
8604 static inline struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
8605 LDKOutPoint ret = owner->a;
8606 ret.is_owned = false;
8609 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(uint64_t owner) {
8610 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
8611 LDKOutPoint ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner_conv);
8612 uint64_t ret_ref = 0;
8613 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8614 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8618 static inline struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
8619 return CVec_MonitorUpdateIdZ_clone(&owner->b);
8621 uint64_tArray __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(uint64_t owner) {
8622 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
8623 LDKCVec_MonitorUpdateIdZ ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner_conv);
8624 uint64_tArray ret_arr = NULL;
8625 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
8626 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
8627 for (size_t r = 0; r < ret_var.datalen; r++) {
8628 LDKMonitorUpdateId ret_conv_17_var = ret_var.data[r];
8629 uint64_t ret_conv_17_ref = 0;
8630 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_17_var);
8631 ret_conv_17_ref = tag_ptr(ret_conv_17_var.inner, ret_conv_17_var.is_owned);
8632 ret_arr_ptr[r] = ret_conv_17_ref;
8639 static inline LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_clone(const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ *orig) {
8640 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ) * orig->datalen, "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ clone bytes"), .datalen = orig->datalen };
8641 for (size_t i = 0; i < ret.datalen; i++) {
8642 ret.data[i] = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(&orig->data[i]);
8646 static inline LDKCVec_PhantomRouteHintsZ CVec_PhantomRouteHintsZ_clone(const LDKCVec_PhantomRouteHintsZ *orig) {
8647 LDKCVec_PhantomRouteHintsZ ret = { .data = MALLOC(sizeof(LDKPhantomRouteHints) * orig->datalen, "LDKCVec_PhantomRouteHintsZ clone bytes"), .datalen = orig->datalen };
8648 for (size_t i = 0; i < ret.datalen; i++) {
8649 ret.data[i] = PhantomRouteHints_clone(&orig->data[i]);
8653 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_ty_from_ptr"))) TS_LDKSignOrCreationError_ty_from_ptr(uint64_t ptr) {
8654 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
8656 case LDKSignOrCreationError_SignError: return 0;
8657 case LDKSignOrCreationError_CreationError: return 1;
8661 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_CreationError_get_creation_error"))) TS_LDKSignOrCreationError_CreationError_get_creation_error(uint64_t ptr) {
8662 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
8663 assert(obj->tag == LDKSignOrCreationError_CreationError);
8664 uint32_t creation_error_conv = LDKCreationError_to_js(obj->creation_error);
8665 return creation_error_conv;
8667 static inline struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8668 LDKInvoice ret = *owner->contents.result;
8669 ret.is_owned = false;
8672 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(uint64_t owner) {
8673 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
8674 LDKInvoice ret_var = CResult_InvoiceSignOrCreationErrorZ_get_ok(owner_conv);
8675 uint64_t ret_ref = 0;
8676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8677 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8681 static inline struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8682 CHECK(!owner->result_ok);
8683 return SignOrCreationError_clone(&*owner->contents.err);
8685 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_err(uint64_t owner) {
8686 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
8687 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
8688 *ret_copy = CResult_InvoiceSignOrCreationErrorZ_get_err(owner_conv);
8689 uint64_t ret_ref = tag_ptr(ret_copy, true);
8693 uint32_t __attribute__((export_name("TS_LDKParseError_ty_from_ptr"))) TS_LDKParseError_ty_from_ptr(uint64_t ptr) {
8694 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8696 case LDKParseError_Bech32Error: return 0;
8697 case LDKParseError_ParseAmountError: return 1;
8698 case LDKParseError_MalformedSignature: return 2;
8699 case LDKParseError_BadPrefix: return 3;
8700 case LDKParseError_UnknownCurrency: return 4;
8701 case LDKParseError_UnknownSiPrefix: return 5;
8702 case LDKParseError_MalformedHRP: return 6;
8703 case LDKParseError_TooShortDataPart: return 7;
8704 case LDKParseError_UnexpectedEndOfTaggedFields: return 8;
8705 case LDKParseError_DescriptionDecodeError: return 9;
8706 case LDKParseError_PaddingError: return 10;
8707 case LDKParseError_IntegerOverflowError: return 11;
8708 case LDKParseError_InvalidSegWitProgramLength: return 12;
8709 case LDKParseError_InvalidPubKeyHashLength: return 13;
8710 case LDKParseError_InvalidScriptHashLength: return 14;
8711 case LDKParseError_InvalidRecoveryId: return 15;
8712 case LDKParseError_InvalidSliceLength: return 16;
8713 case LDKParseError_Skip: return 17;
8717 uint64_t __attribute__((export_name("TS_LDKParseError_Bech32Error_get_bech32_error"))) TS_LDKParseError_Bech32Error_get_bech32_error(uint64_t ptr) {
8718 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8719 assert(obj->tag == LDKParseError_Bech32Error);
8720 uint64_t bech32_error_ref = tag_ptr(&obj->bech32_error, false);
8721 return bech32_error_ref;
8723 int32_t __attribute__((export_name("TS_LDKParseError_ParseAmountError_get_parse_amount_error"))) TS_LDKParseError_ParseAmountError_get_parse_amount_error(uint64_t ptr) {
8724 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8725 assert(obj->tag == LDKParseError_ParseAmountError);
8726 /*obj->parse_amount_error*/
8729 uint32_t __attribute__((export_name("TS_LDKParseError_MalformedSignature_get_malformed_signature"))) TS_LDKParseError_MalformedSignature_get_malformed_signature(uint64_t ptr) {
8730 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8731 assert(obj->tag == LDKParseError_MalformedSignature);
8732 uint32_t malformed_signature_conv = LDKSecp256k1Error_to_js(obj->malformed_signature);
8733 return malformed_signature_conv;
8735 int32_t __attribute__((export_name("TS_LDKParseError_DescriptionDecodeError_get_description_decode_error"))) TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(uint64_t ptr) {
8736 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8737 assert(obj->tag == LDKParseError_DescriptionDecodeError);
8738 /*obj->description_decode_error*/
8741 jstring __attribute__((export_name("TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length"))) TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(uint64_t ptr) {
8742 LDKParseError *obj = (LDKParseError*)untag_ptr(ptr);
8743 assert(obj->tag == LDKParseError_InvalidSliceLength);
8744 LDKStr invalid_slice_length_str = obj->invalid_slice_length;
8745 jstring invalid_slice_length_conv = str_ref_to_ts(invalid_slice_length_str.chars, invalid_slice_length_str.len);
8746 return invalid_slice_length_conv;
8748 static inline enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
8749 CHECK(owner->result_ok);
8750 return SiPrefix_clone(&*owner->contents.result);
8752 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_ok"))) TS_CResult_SiPrefixParseErrorZ_get_ok(uint64_t owner) {
8753 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(owner);
8754 uint32_t ret_conv = LDKSiPrefix_to_js(CResult_SiPrefixParseErrorZ_get_ok(owner_conv));
8758 static inline struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
8759 CHECK(!owner->result_ok);
8760 return ParseError_clone(&*owner->contents.err);
8762 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_err"))) TS_CResult_SiPrefixParseErrorZ_get_err(uint64_t owner) {
8763 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(owner);
8764 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
8765 *ret_copy = CResult_SiPrefixParseErrorZ_get_err(owner_conv);
8766 uint64_t ret_ref = tag_ptr(ret_copy, true);
8770 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_ty_from_ptr"))) TS_LDKParseOrSemanticError_ty_from_ptr(uint64_t ptr) {
8771 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
8773 case LDKParseOrSemanticError_ParseError: return 0;
8774 case LDKParseOrSemanticError_SemanticError: return 1;
8778 uint64_t __attribute__((export_name("TS_LDKParseOrSemanticError_ParseError_get_parse_error"))) TS_LDKParseOrSemanticError_ParseError_get_parse_error(uint64_t ptr) {
8779 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
8780 assert(obj->tag == LDKParseOrSemanticError_ParseError);
8781 uint64_t parse_error_ref = tag_ptr(&obj->parse_error, false);
8782 return parse_error_ref;
8784 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_SemanticError_get_semantic_error"))) TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(uint64_t ptr) {
8785 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
8786 assert(obj->tag == LDKParseOrSemanticError_SemanticError);
8787 uint32_t semantic_error_conv = LDKSemanticError_to_js(obj->semantic_error);
8788 return semantic_error_conv;
8790 static inline struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
8791 LDKInvoice ret = *owner->contents.result;
8792 ret.is_owned = false;
8795 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(uint64_t owner) {
8796 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
8797 LDKInvoice ret_var = CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner_conv);
8798 uint64_t ret_ref = 0;
8799 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8800 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8804 static inline struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
8805 CHECK(!owner->result_ok);
8806 return ParseOrSemanticError_clone(&*owner->contents.err);
8808 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(uint64_t owner) {
8809 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
8810 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
8811 *ret_copy = CResult_InvoiceParseOrSemanticErrorZ_get_err(owner_conv);
8812 uint64_t ret_ref = tag_ptr(ret_copy, true);
8816 static inline struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
8817 LDKSignedRawInvoice ret = *owner->contents.result;
8818 ret.is_owned = false;
8821 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(uint64_t owner) {
8822 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(owner);
8823 LDKSignedRawInvoice ret_var = CResult_SignedRawInvoiceParseErrorZ_get_ok(owner_conv);
8824 uint64_t ret_ref = 0;
8825 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8826 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8830 static inline struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
8831 CHECK(!owner->result_ok);
8832 return ParseError_clone(&*owner->contents.err);
8834 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_err(uint64_t owner) {
8835 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(owner);
8836 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
8837 *ret_copy = CResult_SignedRawInvoiceParseErrorZ_get_err(owner_conv);
8838 uint64_t ret_ref = tag_ptr(ret_copy, true);
8842 static inline struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
8843 LDKRawInvoice ret = owner->a;
8844 ret.is_owned = false;
8847 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint64_t owner) {
8848 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
8849 LDKRawInvoice ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner_conv);
8850 uint64_t ret_ref = 0;
8851 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8852 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8856 static inline struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
8857 return ThirtyTwoBytes_clone(&owner->b);
8859 int8_tArray __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint64_t owner) {
8860 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
8861 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
8862 memcpy(ret_arr->elems, C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner_conv).data, 32);
8866 static inline struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
8867 LDKInvoiceSignature ret = owner->c;
8868 ret.is_owned = false;
8871 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint64_t owner) {
8872 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(owner);
8873 LDKInvoiceSignature ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner_conv);
8874 uint64_t ret_ref = 0;
8875 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8876 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8880 static inline struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
8881 LDKPayeePubKey ret = *owner->contents.result;
8882 ret.is_owned = false;
8885 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_ok"))) TS_CResult_PayeePubKeyErrorZ_get_ok(uint64_t owner) {
8886 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(owner);
8887 LDKPayeePubKey ret_var = CResult_PayeePubKeyErrorZ_get_ok(owner_conv);
8888 uint64_t ret_ref = 0;
8889 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8890 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8894 static inline enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
8895 CHECK(!owner->result_ok);
8896 return *owner->contents.err;
8898 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_err"))) TS_CResult_PayeePubKeyErrorZ_get_err(uint64_t owner) {
8899 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(owner);
8900 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PayeePubKeyErrorZ_get_err(owner_conv));
8904 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
8905 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
8906 for (size_t i = 0; i < ret.datalen; i++) {
8907 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
8911 static inline struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
8912 LDKPositiveTimestamp ret = *owner->contents.result;
8913 ret.is_owned = false;
8916 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_get_ok(uint64_t owner) {
8917 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
8918 LDKPositiveTimestamp ret_var = CResult_PositiveTimestampCreationErrorZ_get_ok(owner_conv);
8919 uint64_t ret_ref = 0;
8920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8921 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8925 static inline enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
8926 CHECK(!owner->result_ok);
8927 return CreationError_clone(&*owner->contents.err);
8929 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_err"))) TS_CResult_PositiveTimestampCreationErrorZ_get_err(uint64_t owner) {
8930 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
8931 uint32_t ret_conv = LDKCreationError_to_js(CResult_PositiveTimestampCreationErrorZ_get_err(owner_conv));
8935 static inline void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
8936 CHECK(owner->result_ok);
8937 return *owner->contents.result;
8939 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_ok"))) TS_CResult_NoneSemanticErrorZ_get_ok(uint64_t owner) {
8940 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(owner);
8941 CResult_NoneSemanticErrorZ_get_ok(owner_conv);
8944 static inline enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
8945 CHECK(!owner->result_ok);
8946 return SemanticError_clone(&*owner->contents.err);
8948 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_err"))) TS_CResult_NoneSemanticErrorZ_get_err(uint64_t owner) {
8949 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(owner);
8950 uint32_t ret_conv = LDKSemanticError_to_js(CResult_NoneSemanticErrorZ_get_err(owner_conv));
8954 static inline struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
8955 LDKInvoice ret = *owner->contents.result;
8956 ret.is_owned = false;
8959 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_ok"))) TS_CResult_InvoiceSemanticErrorZ_get_ok(uint64_t owner) {
8960 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(owner);
8961 LDKInvoice ret_var = CResult_InvoiceSemanticErrorZ_get_ok(owner_conv);
8962 uint64_t ret_ref = 0;
8963 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8964 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8968 static inline enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
8969 CHECK(!owner->result_ok);
8970 return SemanticError_clone(&*owner->contents.err);
8972 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_err"))) TS_CResult_InvoiceSemanticErrorZ_get_err(uint64_t owner) {
8973 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(owner);
8974 uint32_t ret_conv = LDKSemanticError_to_js(CResult_InvoiceSemanticErrorZ_get_err(owner_conv));
8978 static inline struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
8979 LDKDescription ret = *owner->contents.result;
8980 ret.is_owned = false;
8983 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_ok"))) TS_CResult_DescriptionCreationErrorZ_get_ok(uint64_t owner) {
8984 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
8985 LDKDescription ret_var = CResult_DescriptionCreationErrorZ_get_ok(owner_conv);
8986 uint64_t ret_ref = 0;
8987 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8988 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8992 static inline enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
8993 CHECK(!owner->result_ok);
8994 return CreationError_clone(&*owner->contents.err);
8996 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_err"))) TS_CResult_DescriptionCreationErrorZ_get_err(uint64_t owner) {
8997 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
8998 uint32_t ret_conv = LDKCreationError_to_js(CResult_DescriptionCreationErrorZ_get_err(owner_conv));
9002 static inline struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
9003 LDKPrivateRoute ret = *owner->contents.result;
9004 ret.is_owned = false;
9007 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_ok"))) TS_CResult_PrivateRouteCreationErrorZ_get_ok(uint64_t owner) {
9008 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
9009 LDKPrivateRoute ret_var = CResult_PrivateRouteCreationErrorZ_get_ok(owner_conv);
9010 uint64_t ret_ref = 0;
9011 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
9012 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
9016 static inline enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
9017 CHECK(!owner->result_ok);
9018 return CreationError_clone(&*owner->contents.err);
9020 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_err"))) TS_CResult_PrivateRouteCreationErrorZ_get_err(uint64_t owner) {
9021 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
9022 uint32_t ret_conv = LDKCreationError_to_js(CResult_PrivateRouteCreationErrorZ_get_err(owner_conv));
9026 typedef struct LDKScore_JCalls {
9027 atomic_size_t refcnt;
9028 uint32_t instance_ptr;
9030 static void LDKScore_JCalls_free(void* this_arg) {
9031 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9032 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9036 uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage) {
9037 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9038 int64_t short_channel_id_conv = short_channel_id;
9039 LDKNodeId source_var = *source;
9040 uint64_t source_ref = 0;
9041 source_var = NodeId_clone(&source_var);
9042 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
9043 source_ref = tag_ptr(source_var.inner, source_var.is_owned);
9044 LDKNodeId target_var = *target;
9045 uint64_t target_ref = 0;
9046 target_var = NodeId_clone(&target_var);
9047 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
9048 target_ref = tag_ptr(target_var.inner, target_var.is_owned);
9049 LDKChannelUsage usage_var = usage;
9050 uint64_t usage_ref = 0;
9051 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
9052 usage_ref = tag_ptr(usage_var.inner, usage_var.is_owned);
9053 return js_invoke_function_bbbbuu(j_calls->instance_ptr, 42, short_channel_id_conv, source_ref, target_ref, usage_ref, 0, 0);
9055 void payment_path_failed_LDKScore_jcall(void* this_arg, const LDKPath * path, uint64_t short_channel_id) {
9056 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9057 LDKPath path_var = *path;
9058 uint64_t path_ref = 0;
9059 path_var = Path_clone(&path_var);
9060 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9061 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9062 int64_t short_channel_id_conv = short_channel_id;
9063 js_invoke_function_bbuuuu(j_calls->instance_ptr, 43, path_ref, short_channel_id_conv, 0, 0, 0, 0);
9065 void payment_path_successful_LDKScore_jcall(void* this_arg, const LDKPath * path) {
9066 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9067 LDKPath path_var = *path;
9068 uint64_t path_ref = 0;
9069 path_var = Path_clone(&path_var);
9070 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9071 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9072 js_invoke_function_buuuuu(j_calls->instance_ptr, 44, path_ref, 0, 0, 0, 0, 0);
9074 void probe_failed_LDKScore_jcall(void* this_arg, const LDKPath * path, uint64_t short_channel_id) {
9075 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9076 LDKPath path_var = *path;
9077 uint64_t path_ref = 0;
9078 path_var = Path_clone(&path_var);
9079 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9080 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9081 int64_t short_channel_id_conv = short_channel_id;
9082 js_invoke_function_bbuuuu(j_calls->instance_ptr, 45, path_ref, short_channel_id_conv, 0, 0, 0, 0);
9084 void probe_successful_LDKScore_jcall(void* this_arg, const LDKPath * path) {
9085 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9086 LDKPath path_var = *path;
9087 uint64_t path_ref = 0;
9088 path_var = Path_clone(&path_var);
9089 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9090 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
9091 js_invoke_function_buuuuu(j_calls->instance_ptr, 46, path_ref, 0, 0, 0, 0, 0);
9093 LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
9094 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
9095 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 47, 0, 0, 0, 0, 0, 0);
9096 LDKCVec_u8Z ret_ref;
9097 ret_ref.datalen = ret->arr_len;
9098 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
9099 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
9102 static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
9103 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
9104 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9106 static inline LDKScore LDKScore_init (JSValue o) {
9107 LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
9108 atomic_init(&calls->refcnt, 1);
9109 calls->instance_ptr = o;
9112 .this_arg = (void*) calls,
9113 .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall,
9114 .payment_path_failed = payment_path_failed_LDKScore_jcall,
9115 .payment_path_successful = payment_path_successful_LDKScore_jcall,
9116 .probe_failed = probe_failed_LDKScore_jcall,
9117 .probe_successful = probe_successful_LDKScore_jcall,
9118 .write = write_LDKScore_jcall,
9119 .free = LDKScore_JCalls_free,
9123 uint64_t __attribute__((export_name("TS_LDKScore_new"))) TS_LDKScore_new(JSValue o) {
9124 LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
9125 *res_ptr = LDKScore_init(o);
9126 return tag_ptr(res_ptr, true);
9128 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) {
9129 void* this_arg_ptr = untag_ptr(this_arg);
9130 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9131 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9132 LDKNodeId source_conv;
9133 source_conv.inner = untag_ptr(source);
9134 source_conv.is_owned = ptr_is_owned(source);
9135 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
9136 source_conv.is_owned = false;
9137 LDKNodeId target_conv;
9138 target_conv.inner = untag_ptr(target);
9139 target_conv.is_owned = ptr_is_owned(target);
9140 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
9141 target_conv.is_owned = false;
9142 LDKChannelUsage usage_conv;
9143 usage_conv.inner = untag_ptr(usage);
9144 usage_conv.is_owned = ptr_is_owned(usage);
9145 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
9146 usage_conv = ChannelUsage_clone(&usage_conv);
9147 int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv);
9151 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) {
9152 void* this_arg_ptr = untag_ptr(this_arg);
9153 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9154 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9156 path_conv.inner = untag_ptr(path);
9157 path_conv.is_owned = ptr_is_owned(path);
9158 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9159 path_conv.is_owned = false;
9160 (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, &path_conv, short_channel_id);
9163 void __attribute__((export_name("TS_Score_payment_path_successful"))) TS_Score_payment_path_successful(uint64_t this_arg, uint64_t path) {
9164 void* this_arg_ptr = untag_ptr(this_arg);
9165 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9166 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9168 path_conv.inner = untag_ptr(path);
9169 path_conv.is_owned = ptr_is_owned(path);
9170 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9171 path_conv.is_owned = false;
9172 (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, &path_conv);
9175 void __attribute__((export_name("TS_Score_probe_failed"))) TS_Score_probe_failed(uint64_t this_arg, uint64_t path, int64_t short_channel_id) {
9176 void* this_arg_ptr = untag_ptr(this_arg);
9177 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9178 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9180 path_conv.inner = untag_ptr(path);
9181 path_conv.is_owned = ptr_is_owned(path);
9182 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9183 path_conv.is_owned = false;
9184 (this_arg_conv->probe_failed)(this_arg_conv->this_arg, &path_conv, short_channel_id);
9187 void __attribute__((export_name("TS_Score_probe_successful"))) TS_Score_probe_successful(uint64_t this_arg, uint64_t path) {
9188 void* this_arg_ptr = untag_ptr(this_arg);
9189 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9190 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9192 path_conv.inner = untag_ptr(path);
9193 path_conv.is_owned = ptr_is_owned(path);
9194 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
9195 path_conv.is_owned = false;
9196 (this_arg_conv->probe_successful)(this_arg_conv->this_arg, &path_conv);
9199 int8_tArray __attribute__((export_name("TS_Score_write"))) TS_Score_write(uint64_t this_arg) {
9200 void* this_arg_ptr = untag_ptr(this_arg);
9201 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9202 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
9203 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
9204 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
9205 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
9206 CVec_u8Z_free(ret_var);
9210 typedef struct LDKLockableScore_JCalls {
9211 atomic_size_t refcnt;
9212 uint32_t instance_ptr;
9213 } LDKLockableScore_JCalls;
9214 static void LDKLockableScore_JCalls_free(void* this_arg) {
9215 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
9216 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9220 LDKScore lock_LDKLockableScore_jcall(const void* this_arg) {
9221 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
9222 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 48, 0, 0, 0, 0, 0, 0);
9223 void* ret_ptr = untag_ptr(ret);
9224 CHECK_ACCESS(ret_ptr);
9225 LDKScore ret_conv = *(LDKScore*)(ret_ptr);
9226 if (ret_conv.free == LDKScore_JCalls_free) {
9227 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
9228 LDKScore_JCalls_cloned(&ret_conv);
9229 }// WARNING: we may need a move here but no clone is available for LDKScore
9233 static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
9234 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
9235 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9237 static inline LDKLockableScore LDKLockableScore_init (JSValue o) {
9238 LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
9239 atomic_init(&calls->refcnt, 1);
9240 calls->instance_ptr = o;
9242 LDKLockableScore ret = {
9243 .this_arg = (void*) calls,
9244 .lock = lock_LDKLockableScore_jcall,
9245 .free = LDKLockableScore_JCalls_free,
9249 uint64_t __attribute__((export_name("TS_LDKLockableScore_new"))) TS_LDKLockableScore_new(JSValue o) {
9250 LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
9251 *res_ptr = LDKLockableScore_init(o);
9252 return tag_ptr(res_ptr, true);
9254 uint64_t __attribute__((export_name("TS_LockableScore_lock"))) TS_LockableScore_lock(uint64_t this_arg) {
9255 void* this_arg_ptr = untag_ptr(this_arg);
9256 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9257 LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
9258 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
9259 *ret_ret = (this_arg_conv->lock)(this_arg_conv->this_arg);
9260 return tag_ptr(ret_ret, true);
9263 typedef struct LDKWriteableScore_JCalls {
9264 atomic_size_t refcnt;
9265 uint32_t instance_ptr;
9266 LDKLockableScore_JCalls* LockableScore;
9267 } LDKWriteableScore_JCalls;
9268 static void LDKWriteableScore_JCalls_free(void* this_arg) {
9269 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
9270 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9274 LDKCVec_u8Z write_LDKWriteableScore_jcall(const void* this_arg) {
9275 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
9276 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 49, 0, 0, 0, 0, 0, 0);
9277 LDKCVec_u8Z ret_ref;
9278 ret_ref.datalen = ret->arr_len;
9279 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
9280 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
9283 static void LDKWriteableScore_JCalls_cloned(LDKWriteableScore* new_obj) {
9284 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) new_obj->this_arg;
9285 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9286 atomic_fetch_add_explicit(&j_calls->LockableScore->refcnt, 1, memory_order_release);
9288 static inline LDKWriteableScore LDKWriteableScore_init (JSValue o, JSValue LockableScore) {
9289 LDKWriteableScore_JCalls *calls = MALLOC(sizeof(LDKWriteableScore_JCalls), "LDKWriteableScore_JCalls");
9290 atomic_init(&calls->refcnt, 1);
9291 calls->instance_ptr = o;
9293 LDKWriteableScore ret = {
9294 .this_arg = (void*) calls,
9295 .write = write_LDKWriteableScore_jcall,
9296 .free = LDKWriteableScore_JCalls_free,
9297 .LockableScore = LDKLockableScore_init(LockableScore),
9299 calls->LockableScore = ret.LockableScore.this_arg;
9302 uint64_t __attribute__((export_name("TS_LDKWriteableScore_new"))) TS_LDKWriteableScore_new(JSValue o, JSValue LockableScore) {
9303 LDKWriteableScore *res_ptr = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
9304 *res_ptr = LDKWriteableScore_init(o, LockableScore);
9305 return tag_ptr(res_ptr, true);
9307 int8_tArray __attribute__((export_name("TS_WriteableScore_write"))) TS_WriteableScore_write(uint64_t this_arg) {
9308 void* this_arg_ptr = untag_ptr(this_arg);
9309 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9310 LDKWriteableScore* this_arg_conv = (LDKWriteableScore*)this_arg_ptr;
9311 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
9312 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
9313 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
9314 CVec_u8Z_free(ret_var);
9318 typedef struct LDKPersister_JCalls {
9319 atomic_size_t refcnt;
9320 uint32_t instance_ptr;
9321 } LDKPersister_JCalls;
9322 static void LDKPersister_JCalls_free(void* this_arg) {
9323 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9324 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9328 LDKCResult_NoneErrorZ persist_manager_LDKPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
9329 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9330 LDKChannelManager channel_manager_var = *channel_manager;
9331 uint64_t channel_manager_ref = 0;
9332 // WARNING: we may need a move here but no clone is available for LDKChannelManager
9333 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
9334 channel_manager_ref = tag_ptr(channel_manager_var.inner, channel_manager_var.is_owned);
9335 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 50, channel_manager_ref, 0, 0, 0, 0, 0);
9336 void* ret_ptr = untag_ptr(ret);
9337 CHECK_ACCESS(ret_ptr);
9338 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
9339 FREE(untag_ptr(ret));
9342 LDKCResult_NoneErrorZ persist_graph_LDKPersister_jcall(const void* this_arg, const LDKNetworkGraph * network_graph) {
9343 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9344 LDKNetworkGraph network_graph_var = *network_graph;
9345 uint64_t network_graph_ref = 0;
9346 // WARNING: we may need a move here but no clone is available for LDKNetworkGraph
9347 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_var);
9348 network_graph_ref = tag_ptr(network_graph_var.inner, network_graph_var.is_owned);
9349 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 51, network_graph_ref, 0, 0, 0, 0, 0);
9350 void* ret_ptr = untag_ptr(ret);
9351 CHECK_ACCESS(ret_ptr);
9352 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
9353 FREE(untag_ptr(ret));
9356 LDKCResult_NoneErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKWriteableScore * scorer) {
9357 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
9358 // WARNING: This object doesn't live past this scope, needs clone!
9359 uint64_t ret_scorer = tag_ptr(scorer, false);
9360 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 52, ret_scorer, 0, 0, 0, 0, 0);
9361 void* ret_ptr = untag_ptr(ret);
9362 CHECK_ACCESS(ret_ptr);
9363 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
9364 FREE(untag_ptr(ret));
9367 static void LDKPersister_JCalls_cloned(LDKPersister* new_obj) {
9368 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) new_obj->this_arg;
9369 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9371 static inline LDKPersister LDKPersister_init (JSValue o) {
9372 LDKPersister_JCalls *calls = MALLOC(sizeof(LDKPersister_JCalls), "LDKPersister_JCalls");
9373 atomic_init(&calls->refcnt, 1);
9374 calls->instance_ptr = o;
9376 LDKPersister ret = {
9377 .this_arg = (void*) calls,
9378 .persist_manager = persist_manager_LDKPersister_jcall,
9379 .persist_graph = persist_graph_LDKPersister_jcall,
9380 .persist_scorer = persist_scorer_LDKPersister_jcall,
9381 .free = LDKPersister_JCalls_free,
9385 uint64_t __attribute__((export_name("TS_LDKPersister_new"))) TS_LDKPersister_new(JSValue o) {
9386 LDKPersister *res_ptr = MALLOC(sizeof(LDKPersister), "LDKPersister");
9387 *res_ptr = LDKPersister_init(o);
9388 return tag_ptr(res_ptr, true);
9390 uint64_t __attribute__((export_name("TS_Persister_persist_manager"))) TS_Persister_persist_manager(uint64_t this_arg, uint64_t channel_manager) {
9391 void* this_arg_ptr = untag_ptr(this_arg);
9392 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9393 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9394 LDKChannelManager channel_manager_conv;
9395 channel_manager_conv.inner = untag_ptr(channel_manager);
9396 channel_manager_conv.is_owned = ptr_is_owned(channel_manager);
9397 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
9398 channel_manager_conv.is_owned = false;
9399 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9400 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
9401 return tag_ptr(ret_conv, true);
9404 uint64_t __attribute__((export_name("TS_Persister_persist_graph"))) TS_Persister_persist_graph(uint64_t this_arg, uint64_t network_graph) {
9405 void* this_arg_ptr = untag_ptr(this_arg);
9406 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9407 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9408 LDKNetworkGraph network_graph_conv;
9409 network_graph_conv.inner = untag_ptr(network_graph);
9410 network_graph_conv.is_owned = ptr_is_owned(network_graph);
9411 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
9412 network_graph_conv.is_owned = false;
9413 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9414 *ret_conv = (this_arg_conv->persist_graph)(this_arg_conv->this_arg, &network_graph_conv);
9415 return tag_ptr(ret_conv, true);
9418 uint64_t __attribute__((export_name("TS_Persister_persist_scorer"))) TS_Persister_persist_scorer(uint64_t this_arg, uint64_t scorer) {
9419 void* this_arg_ptr = untag_ptr(this_arg);
9420 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9421 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9422 void* scorer_ptr = untag_ptr(scorer);
9423 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
9424 LDKWriteableScore* scorer_conv = (LDKWriteableScore*)scorer_ptr;
9425 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9426 *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, scorer_conv);
9427 return tag_ptr(ret_conv, true);
9430 typedef struct LDKFutureCallback_JCalls {
9431 atomic_size_t refcnt;
9432 uint32_t instance_ptr;
9433 } LDKFutureCallback_JCalls;
9434 static void LDKFutureCallback_JCalls_free(void* this_arg) {
9435 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
9436 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9440 void call_LDKFutureCallback_jcall(const void* this_arg) {
9441 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
9442 js_invoke_function_uuuuuu(j_calls->instance_ptr, 53, 0, 0, 0, 0, 0, 0);
9444 static void LDKFutureCallback_JCalls_cloned(LDKFutureCallback* new_obj) {
9445 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) new_obj->this_arg;
9446 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9448 static inline LDKFutureCallback LDKFutureCallback_init (JSValue o) {
9449 LDKFutureCallback_JCalls *calls = MALLOC(sizeof(LDKFutureCallback_JCalls), "LDKFutureCallback_JCalls");
9450 atomic_init(&calls->refcnt, 1);
9451 calls->instance_ptr = o;
9453 LDKFutureCallback ret = {
9454 .this_arg = (void*) calls,
9455 .call = call_LDKFutureCallback_jcall,
9456 .free = LDKFutureCallback_JCalls_free,
9460 uint64_t __attribute__((export_name("TS_LDKFutureCallback_new"))) TS_LDKFutureCallback_new(JSValue o) {
9461 LDKFutureCallback *res_ptr = MALLOC(sizeof(LDKFutureCallback), "LDKFutureCallback");
9462 *res_ptr = LDKFutureCallback_init(o);
9463 return tag_ptr(res_ptr, true);
9465 void __attribute__((export_name("TS_FutureCallback_call"))) TS_FutureCallback_call(uint64_t this_arg) {
9466 void* this_arg_ptr = untag_ptr(this_arg);
9467 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9468 LDKFutureCallback* this_arg_conv = (LDKFutureCallback*)this_arg_ptr;
9469 (this_arg_conv->call)(this_arg_conv->this_arg);
9472 typedef struct LDKListen_JCalls {
9473 atomic_size_t refcnt;
9474 uint32_t instance_ptr;
9476 static void LDKListen_JCalls_free(void* this_arg) {
9477 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9478 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9482 void filtered_block_connected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9483 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9484 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9485 memcpy(header_arr->elems, *header, 80);
9486 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9487 uint64_tArray txdata_arr = NULL;
9488 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
9489 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
9490 for (size_t c = 0; c < txdata_var.datalen; c++) {
9491 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9492 *txdata_conv_28_conv = txdata_var.data[c];
9493 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
9496 FREE(txdata_var.data);
9497 int32_t height_conv = height;
9498 js_invoke_function_uuuuuu(j_calls->instance_ptr, 54, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
9500 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
9501 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9502 LDKu8slice block_var = block;
9503 int8_tArray block_arr = init_int8_tArray(block_var.datalen, __LINE__);
9504 memcpy(block_arr->elems, block_var.data, block_var.datalen);
9505 int32_t height_conv = height;
9506 js_invoke_function_uuuuuu(j_calls->instance_ptr, 55, (uint32_t)block_arr, height_conv, 0, 0, 0, 0);
9508 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9509 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9510 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9511 memcpy(header_arr->elems, *header, 80);
9512 int32_t height_conv = height;
9513 js_invoke_function_uuuuuu(j_calls->instance_ptr, 56, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
9515 static void LDKListen_JCalls_cloned(LDKListen* new_obj) {
9516 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) new_obj->this_arg;
9517 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9519 static inline LDKListen LDKListen_init (JSValue o) {
9520 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
9521 atomic_init(&calls->refcnt, 1);
9522 calls->instance_ptr = o;
9525 .this_arg = (void*) calls,
9526 .filtered_block_connected = filtered_block_connected_LDKListen_jcall,
9527 .block_connected = block_connected_LDKListen_jcall,
9528 .block_disconnected = block_disconnected_LDKListen_jcall,
9529 .free = LDKListen_JCalls_free,
9533 uint64_t __attribute__((export_name("TS_LDKListen_new"))) TS_LDKListen_new(JSValue o) {
9534 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
9535 *res_ptr = LDKListen_init(o);
9536 return tag_ptr(res_ptr, true);
9538 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) {
9539 void* this_arg_ptr = untag_ptr(this_arg);
9540 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9541 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9542 uint8_t header_arr[80];
9543 CHECK(header->arr_len == 80);
9544 memcpy(header_arr, header->elems, 80); FREE(header);
9545 uint8_t (*header_ref)[80] = &header_arr;
9546 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9547 txdata_constr.datalen = txdata->arr_len;
9548 if (txdata_constr.datalen > 0)
9549 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9551 txdata_constr.data = NULL;
9552 uint64_t* txdata_vals = txdata->elems;
9553 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9554 uint64_t txdata_conv_28 = txdata_vals[c];
9555 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
9556 CHECK_ACCESS(txdata_conv_28_ptr);
9557 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9558 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
9559 txdata_constr.data[c] = txdata_conv_28_conv;
9562 (this_arg_conv->filtered_block_connected)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9565 void __attribute__((export_name("TS_Listen_block_connected"))) TS_Listen_block_connected(uint64_t this_arg, int8_tArray block, int32_t height) {
9566 void* this_arg_ptr = untag_ptr(this_arg);
9567 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9568 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9569 LDKu8slice block_ref;
9570 block_ref.datalen = block->arr_len;
9571 block_ref.data = block->elems;
9572 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
9576 void __attribute__((export_name("TS_Listen_block_disconnected"))) TS_Listen_block_disconnected(uint64_t this_arg, int8_tArray header, int32_t height) {
9577 void* this_arg_ptr = untag_ptr(this_arg);
9578 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9579 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9580 uint8_t header_arr[80];
9581 CHECK(header->arr_len == 80);
9582 memcpy(header_arr, header->elems, 80); FREE(header);
9583 uint8_t (*header_ref)[80] = &header_arr;
9584 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
9587 typedef struct LDKConfirm_JCalls {
9588 atomic_size_t refcnt;
9589 uint32_t instance_ptr;
9590 } LDKConfirm_JCalls;
9591 static void LDKConfirm_JCalls_free(void* this_arg) {
9592 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9593 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9597 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9598 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9599 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9600 memcpy(header_arr->elems, *header, 80);
9601 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9602 uint64_tArray txdata_arr = NULL;
9603 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
9604 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
9605 for (size_t c = 0; c < txdata_var.datalen; c++) {
9606 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9607 *txdata_conv_28_conv = txdata_var.data[c];
9608 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
9611 FREE(txdata_var.data);
9612 int32_t height_conv = height;
9613 js_invoke_function_uuuuuu(j_calls->instance_ptr, 57, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
9615 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
9616 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9617 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
9618 memcpy(txid_arr->elems, *txid, 32);
9619 js_invoke_function_uuuuuu(j_calls->instance_ptr, 58, (uint32_t)txid_arr, 0, 0, 0, 0, 0);
9621 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9622 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9623 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9624 memcpy(header_arr->elems, *header, 80);
9625 int32_t height_conv = height;
9626 js_invoke_function_uuuuuu(j_calls->instance_ptr, 59, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
9628 LDKCVec_C2Tuple_TxidBlockHashZZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
9629 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9630 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 60, 0, 0, 0, 0, 0, 0);
9631 LDKCVec_C2Tuple_TxidBlockHashZZ ret_constr;
9632 ret_constr.datalen = ret->arr_len;
9633 if (ret_constr.datalen > 0)
9634 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKCVec_C2Tuple_TxidBlockHashZZ Elements");
9636 ret_constr.data = NULL;
9637 uint64_t* ret_vals = ret->elems;
9638 for (size_t z = 0; z < ret_constr.datalen; z++) {
9639 uint64_t ret_conv_25 = ret_vals[z];
9640 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
9641 CHECK_ACCESS(ret_conv_25_ptr);
9642 LDKC2Tuple_TxidBlockHashZ ret_conv_25_conv = *(LDKC2Tuple_TxidBlockHashZ*)(ret_conv_25_ptr);
9643 FREE(untag_ptr(ret_conv_25));
9644 ret_constr.data[z] = ret_conv_25_conv;
9649 static void LDKConfirm_JCalls_cloned(LDKConfirm* new_obj) {
9650 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) new_obj->this_arg;
9651 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9653 static inline LDKConfirm LDKConfirm_init (JSValue o) {
9654 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
9655 atomic_init(&calls->refcnt, 1);
9656 calls->instance_ptr = o;
9659 .this_arg = (void*) calls,
9660 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
9661 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
9662 .best_block_updated = best_block_updated_LDKConfirm_jcall,
9663 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
9664 .free = LDKConfirm_JCalls_free,
9668 uint64_t __attribute__((export_name("TS_LDKConfirm_new"))) TS_LDKConfirm_new(JSValue o) {
9669 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
9670 *res_ptr = LDKConfirm_init(o);
9671 return tag_ptr(res_ptr, true);
9673 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) {
9674 void* this_arg_ptr = untag_ptr(this_arg);
9675 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9676 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9677 uint8_t header_arr[80];
9678 CHECK(header->arr_len == 80);
9679 memcpy(header_arr, header->elems, 80); FREE(header);
9680 uint8_t (*header_ref)[80] = &header_arr;
9681 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9682 txdata_constr.datalen = txdata->arr_len;
9683 if (txdata_constr.datalen > 0)
9684 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9686 txdata_constr.data = NULL;
9687 uint64_t* txdata_vals = txdata->elems;
9688 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9689 uint64_t txdata_conv_28 = txdata_vals[c];
9690 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
9691 CHECK_ACCESS(txdata_conv_28_ptr);
9692 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9693 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
9694 txdata_constr.data[c] = txdata_conv_28_conv;
9697 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9700 void __attribute__((export_name("TS_Confirm_transaction_unconfirmed"))) TS_Confirm_transaction_unconfirmed(uint64_t this_arg, int8_tArray txid) {
9701 void* this_arg_ptr = untag_ptr(this_arg);
9702 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9703 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9704 uint8_t txid_arr[32];
9705 CHECK(txid->arr_len == 32);
9706 memcpy(txid_arr, txid->elems, 32); FREE(txid);
9707 uint8_t (*txid_ref)[32] = &txid_arr;
9708 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
9711 void __attribute__((export_name("TS_Confirm_best_block_updated"))) TS_Confirm_best_block_updated(uint64_t this_arg, int8_tArray header, int32_t height) {
9712 void* this_arg_ptr = untag_ptr(this_arg);
9713 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9714 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9715 uint8_t header_arr[80];
9716 CHECK(header->arr_len == 80);
9717 memcpy(header_arr, header->elems, 80); FREE(header);
9718 uint8_t (*header_ref)[80] = &header_arr;
9719 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
9722 uint64_tArray __attribute__((export_name("TS_Confirm_get_relevant_txids"))) TS_Confirm_get_relevant_txids(uint64_t this_arg) {
9723 void* this_arg_ptr = untag_ptr(this_arg);
9724 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9725 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9726 LDKCVec_C2Tuple_TxidBlockHashZZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
9727 uint64_tArray ret_arr = NULL;
9728 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
9729 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
9730 for (size_t z = 0; z < ret_var.datalen; z++) {
9731 LDKC2Tuple_TxidBlockHashZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
9732 *ret_conv_25_conv = ret_var.data[z];
9733 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
9740 typedef struct LDKPersist_JCalls {
9741 atomic_size_t refcnt;
9742 uint32_t instance_ptr;
9743 } LDKPersist_JCalls;
9744 static void LDKPersist_JCalls_free(void* this_arg) {
9745 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9746 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9750 LDKChannelMonitorUpdateStatus persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9751 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9752 LDKOutPoint channel_id_var = channel_id;
9753 uint64_t channel_id_ref = 0;
9754 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9755 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
9756 LDKChannelMonitor data_var = *data;
9757 uint64_t data_ref = 0;
9758 data_var = ChannelMonitor_clone(&data_var);
9759 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9760 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
9761 LDKMonitorUpdateId update_id_var = update_id;
9762 uint64_t update_id_ref = 0;
9763 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9764 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
9765 uint64_t ret = js_invoke_function_bbbuuu(j_calls->instance_ptr, 61, channel_id_ref, data_ref, update_id_ref, 0, 0, 0);
9766 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
9769 LDKChannelMonitorUpdateStatus update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, LDKChannelMonitorUpdate update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9770 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9771 LDKOutPoint channel_id_var = channel_id;
9772 uint64_t channel_id_ref = 0;
9773 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9774 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
9775 LDKChannelMonitorUpdate update_var = update;
9776 uint64_t update_ref = 0;
9777 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
9778 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
9779 LDKChannelMonitor data_var = *data;
9780 uint64_t data_ref = 0;
9781 data_var = ChannelMonitor_clone(&data_var);
9782 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9783 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
9784 LDKMonitorUpdateId update_id_var = update_id;
9785 uint64_t update_id_ref = 0;
9786 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9787 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
9788 uint64_t ret = js_invoke_function_bbbbuu(j_calls->instance_ptr, 62, channel_id_ref, update_ref, data_ref, update_id_ref, 0, 0);
9789 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
9792 static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
9793 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) new_obj->this_arg;
9794 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9796 static inline LDKPersist LDKPersist_init (JSValue o) {
9797 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
9798 atomic_init(&calls->refcnt, 1);
9799 calls->instance_ptr = o;
9802 .this_arg = (void*) calls,
9803 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
9804 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
9805 .free = LDKPersist_JCalls_free,
9809 uint64_t __attribute__((export_name("TS_LDKPersist_new"))) TS_LDKPersist_new(JSValue o) {
9810 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
9811 *res_ptr = LDKPersist_init(o);
9812 return tag_ptr(res_ptr, true);
9814 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) {
9815 void* this_arg_ptr = untag_ptr(this_arg);
9816 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9817 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9818 LDKOutPoint channel_id_conv;
9819 channel_id_conv.inner = untag_ptr(channel_id);
9820 channel_id_conv.is_owned = ptr_is_owned(channel_id);
9821 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9822 channel_id_conv = OutPoint_clone(&channel_id_conv);
9823 LDKChannelMonitor data_conv;
9824 data_conv.inner = untag_ptr(data);
9825 data_conv.is_owned = ptr_is_owned(data);
9826 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9827 data_conv.is_owned = false;
9828 LDKMonitorUpdateId update_id_conv;
9829 update_id_conv.inner = untag_ptr(update_id);
9830 update_id_conv.is_owned = ptr_is_owned(update_id);
9831 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9832 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9833 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));
9837 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) {
9838 void* this_arg_ptr = untag_ptr(this_arg);
9839 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9840 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9841 LDKOutPoint channel_id_conv;
9842 channel_id_conv.inner = untag_ptr(channel_id);
9843 channel_id_conv.is_owned = ptr_is_owned(channel_id);
9844 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9845 channel_id_conv = OutPoint_clone(&channel_id_conv);
9846 LDKChannelMonitorUpdate update_conv;
9847 update_conv.inner = untag_ptr(update);
9848 update_conv.is_owned = ptr_is_owned(update);
9849 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
9850 update_conv = ChannelMonitorUpdate_clone(&update_conv);
9851 LDKChannelMonitor data_conv;
9852 data_conv.inner = untag_ptr(data);
9853 data_conv.is_owned = ptr_is_owned(data);
9854 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9855 data_conv.is_owned = false;
9856 LDKMonitorUpdateId update_id_conv;
9857 update_id_conv.inner = untag_ptr(update_id);
9858 update_id_conv.is_owned = ptr_is_owned(update_id);
9859 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9860 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9861 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));
9865 typedef struct LDKEventHandler_JCalls {
9866 atomic_size_t refcnt;
9867 uint32_t instance_ptr;
9868 } LDKEventHandler_JCalls;
9869 static void LDKEventHandler_JCalls_free(void* this_arg) {
9870 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
9871 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9875 void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) {
9876 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
9877 LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
9878 *event_copy = event;
9879 uint64_t event_ref = tag_ptr(event_copy, true);
9880 js_invoke_function_buuuuu(j_calls->instance_ptr, 63, event_ref, 0, 0, 0, 0, 0);
9882 static void LDKEventHandler_JCalls_cloned(LDKEventHandler* new_obj) {
9883 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) new_obj->this_arg;
9884 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9886 static inline LDKEventHandler LDKEventHandler_init (JSValue o) {
9887 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
9888 atomic_init(&calls->refcnt, 1);
9889 calls->instance_ptr = o;
9891 LDKEventHandler ret = {
9892 .this_arg = (void*) calls,
9893 .handle_event = handle_event_LDKEventHandler_jcall,
9894 .free = LDKEventHandler_JCalls_free,
9898 uint64_t __attribute__((export_name("TS_LDKEventHandler_new"))) TS_LDKEventHandler_new(JSValue o) {
9899 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
9900 *res_ptr = LDKEventHandler_init(o);
9901 return tag_ptr(res_ptr, true);
9903 void __attribute__((export_name("TS_EventHandler_handle_event"))) TS_EventHandler_handle_event(uint64_t this_arg, uint64_t event) {
9904 void* this_arg_ptr = untag_ptr(this_arg);
9905 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9906 LDKEventHandler* this_arg_conv = (LDKEventHandler*)this_arg_ptr;
9907 void* event_ptr = untag_ptr(event);
9908 CHECK_ACCESS(event_ptr);
9909 LDKEvent event_conv = *(LDKEvent*)(event_ptr);
9910 event_conv = Event_clone((LDKEvent*)untag_ptr(event));
9911 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
9914 typedef struct LDKEventsProvider_JCalls {
9915 atomic_size_t refcnt;
9916 uint32_t instance_ptr;
9917 } LDKEventsProvider_JCalls;
9918 static void LDKEventsProvider_JCalls_free(void* this_arg) {
9919 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
9920 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9924 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
9925 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
9926 LDKEventHandler* handler_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
9927 *handler_ret = handler;
9928 js_invoke_function_buuuuu(j_calls->instance_ptr, 64, tag_ptr(handler_ret, true), 0, 0, 0, 0, 0);
9930 static void LDKEventsProvider_JCalls_cloned(LDKEventsProvider* new_obj) {
9931 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) new_obj->this_arg;
9932 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9934 static inline LDKEventsProvider LDKEventsProvider_init (JSValue o) {
9935 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
9936 atomic_init(&calls->refcnt, 1);
9937 calls->instance_ptr = o;
9939 LDKEventsProvider ret = {
9940 .this_arg = (void*) calls,
9941 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
9942 .free = LDKEventsProvider_JCalls_free,
9946 uint64_t __attribute__((export_name("TS_LDKEventsProvider_new"))) TS_LDKEventsProvider_new(JSValue o) {
9947 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
9948 *res_ptr = LDKEventsProvider_init(o);
9949 return tag_ptr(res_ptr, true);
9951 void __attribute__((export_name("TS_EventsProvider_process_pending_events"))) TS_EventsProvider_process_pending_events(uint64_t this_arg, uint64_t handler) {
9952 void* this_arg_ptr = untag_ptr(this_arg);
9953 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
9954 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)this_arg_ptr;
9955 void* handler_ptr = untag_ptr(handler);
9956 CHECK_ACCESS(handler_ptr);
9957 LDKEventHandler handler_conv = *(LDKEventHandler*)(handler_ptr);
9958 if (handler_conv.free == LDKEventHandler_JCalls_free) {
9959 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
9960 LDKEventHandler_JCalls_cloned(&handler_conv);
9962 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
9965 uint32_t __attribute__((export_name("TS_LDKRetry_ty_from_ptr"))) TS_LDKRetry_ty_from_ptr(uint64_t ptr) {
9966 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
9968 case LDKRetry_Attempts: return 0;
9972 uint32_t __attribute__((export_name("TS_LDKRetry_Attempts_get_attempts"))) TS_LDKRetry_Attempts_get_attempts(uint64_t ptr) {
9973 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
9974 assert(obj->tag == LDKRetry_Attempts);
9975 uint32_t attempts_conv = obj->attempts;
9976 return attempts_conv;
9978 typedef struct LDKMessageSendEventsProvider_JCalls {
9979 atomic_size_t refcnt;
9980 uint32_t instance_ptr;
9981 } LDKMessageSendEventsProvider_JCalls;
9982 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
9983 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
9984 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9988 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
9989 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
9990 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 65, 0, 0, 0, 0, 0, 0);
9991 LDKCVec_MessageSendEventZ ret_constr;
9992 ret_constr.datalen = ret->arr_len;
9993 if (ret_constr.datalen > 0)
9994 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
9996 ret_constr.data = NULL;
9997 uint64_t* ret_vals = ret->elems;
9998 for (size_t s = 0; s < ret_constr.datalen; s++) {
9999 uint64_t ret_conv_18 = ret_vals[s];
10000 void* ret_conv_18_ptr = untag_ptr(ret_conv_18);
10001 CHECK_ACCESS(ret_conv_18_ptr);
10002 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
10003 FREE(untag_ptr(ret_conv_18));
10004 ret_constr.data[s] = ret_conv_18_conv;
10009 static void LDKMessageSendEventsProvider_JCalls_cloned(LDKMessageSendEventsProvider* new_obj) {
10010 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) new_obj->this_arg;
10011 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10013 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JSValue o) {
10014 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
10015 atomic_init(&calls->refcnt, 1);
10016 calls->instance_ptr = o;
10018 LDKMessageSendEventsProvider ret = {
10019 .this_arg = (void*) calls,
10020 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
10021 .free = LDKMessageSendEventsProvider_JCalls_free,
10025 uint64_t __attribute__((export_name("TS_LDKMessageSendEventsProvider_new"))) TS_LDKMessageSendEventsProvider_new(JSValue o) {
10026 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
10027 *res_ptr = LDKMessageSendEventsProvider_init(o);
10028 return tag_ptr(res_ptr, true);
10030 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) {
10031 void* this_arg_ptr = untag_ptr(this_arg);
10032 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10033 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)this_arg_ptr;
10034 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
10035 uint64_tArray ret_arr = NULL;
10036 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
10037 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
10038 for (size_t s = 0; s < ret_var.datalen; s++) {
10039 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
10040 *ret_conv_18_copy = ret_var.data[s];
10041 uint64_t ret_conv_18_ref = tag_ptr(ret_conv_18_copy, true);
10042 ret_arr_ptr[s] = ret_conv_18_ref;
10045 FREE(ret_var.data);
10049 typedef struct LDKChannelMessageHandler_JCalls {
10050 atomic_size_t refcnt;
10051 uint32_t instance_ptr;
10052 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
10053 } LDKChannelMessageHandler_JCalls;
10054 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
10055 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10056 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10060 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKOpenChannel * msg) {
10061 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10062 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10063 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10064 LDKOpenChannel msg_var = *msg;
10065 uint64_t msg_ref = 0;
10066 msg_var = OpenChannel_clone(&msg_var);
10067 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10068 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10069 js_invoke_function_ubuuuu(j_calls->instance_ptr, 66, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10071 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAcceptChannel * msg) {
10072 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10073 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10074 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10075 LDKAcceptChannel msg_var = *msg;
10076 uint64_t msg_ref = 0;
10077 msg_var = AcceptChannel_clone(&msg_var);
10078 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10079 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10080 js_invoke_function_ubuuuu(j_calls->instance_ptr, 67, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10082 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
10083 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10084 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10085 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10086 LDKFundingCreated msg_var = *msg;
10087 uint64_t msg_ref = 0;
10088 msg_var = FundingCreated_clone(&msg_var);
10089 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10090 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10091 js_invoke_function_ubuuuu(j_calls->instance_ptr, 68, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10093 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
10094 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10095 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10096 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10097 LDKFundingSigned msg_var = *msg;
10098 uint64_t msg_ref = 0;
10099 msg_var = FundingSigned_clone(&msg_var);
10100 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10101 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10102 js_invoke_function_ubuuuu(j_calls->instance_ptr, 69, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10104 void handle_channel_ready_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReady * msg) {
10105 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10106 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10107 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10108 LDKChannelReady msg_var = *msg;
10109 uint64_t msg_ref = 0;
10110 msg_var = ChannelReady_clone(&msg_var);
10111 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10112 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10113 js_invoke_function_ubuuuu(j_calls->instance_ptr, 70, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10115 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKShutdown * msg) {
10116 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10117 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10118 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10119 LDKShutdown msg_var = *msg;
10120 uint64_t msg_ref = 0;
10121 msg_var = Shutdown_clone(&msg_var);
10122 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10123 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10124 js_invoke_function_ubuuuu(j_calls->instance_ptr, 71, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10126 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
10127 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10128 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10129 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10130 LDKClosingSigned msg_var = *msg;
10131 uint64_t msg_ref = 0;
10132 msg_var = ClosingSigned_clone(&msg_var);
10133 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10134 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10135 js_invoke_function_ubuuuu(j_calls->instance_ptr, 72, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10137 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
10138 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10139 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10140 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10141 LDKUpdateAddHTLC msg_var = *msg;
10142 uint64_t msg_ref = 0;
10143 msg_var = UpdateAddHTLC_clone(&msg_var);
10144 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10145 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10146 js_invoke_function_ubuuuu(j_calls->instance_ptr, 73, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10148 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
10149 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10150 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10151 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10152 LDKUpdateFulfillHTLC msg_var = *msg;
10153 uint64_t msg_ref = 0;
10154 msg_var = UpdateFulfillHTLC_clone(&msg_var);
10155 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10156 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10157 js_invoke_function_ubuuuu(j_calls->instance_ptr, 74, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10159 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
10160 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10161 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10162 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10163 LDKUpdateFailHTLC msg_var = *msg;
10164 uint64_t msg_ref = 0;
10165 msg_var = UpdateFailHTLC_clone(&msg_var);
10166 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10167 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10168 js_invoke_function_ubuuuu(j_calls->instance_ptr, 75, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10170 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
10171 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10172 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10173 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10174 LDKUpdateFailMalformedHTLC msg_var = *msg;
10175 uint64_t msg_ref = 0;
10176 msg_var = UpdateFailMalformedHTLC_clone(&msg_var);
10177 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10178 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10179 js_invoke_function_ubuuuu(j_calls->instance_ptr, 76, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10181 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
10182 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10183 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10184 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10185 LDKCommitmentSigned msg_var = *msg;
10186 uint64_t msg_ref = 0;
10187 msg_var = CommitmentSigned_clone(&msg_var);
10188 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10189 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10190 js_invoke_function_ubuuuu(j_calls->instance_ptr, 77, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10192 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
10193 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10194 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10195 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10196 LDKRevokeAndACK msg_var = *msg;
10197 uint64_t msg_ref = 0;
10198 msg_var = RevokeAndACK_clone(&msg_var);
10199 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10200 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10201 js_invoke_function_ubuuuu(j_calls->instance_ptr, 78, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10203 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
10204 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10205 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10206 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10207 LDKUpdateFee msg_var = *msg;
10208 uint64_t msg_ref = 0;
10209 msg_var = UpdateFee_clone(&msg_var);
10210 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10211 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10212 js_invoke_function_ubuuuu(j_calls->instance_ptr, 79, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10214 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
10215 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10216 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10217 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10218 LDKAnnouncementSignatures msg_var = *msg;
10219 uint64_t msg_ref = 0;
10220 msg_var = AnnouncementSignatures_clone(&msg_var);
10221 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10222 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10223 js_invoke_function_ubuuuu(j_calls->instance_ptr, 80, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10225 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10226 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10227 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10228 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10229 js_invoke_function_uuuuuu(j_calls->instance_ptr, 81, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10231 LDKCResult_NoneNoneZ peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg, bool inbound) {
10232 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10233 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10234 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10235 LDKInit msg_var = *msg;
10236 uint64_t msg_ref = 0;
10237 msg_var = Init_clone(&msg_var);
10238 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10239 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10240 jboolean inbound_conv = inbound;
10241 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);
10242 void* ret_ptr = untag_ptr(ret);
10243 CHECK_ACCESS(ret_ptr);
10244 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
10245 FREE(untag_ptr(ret));
10248 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
10249 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10250 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10251 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10252 LDKChannelReestablish msg_var = *msg;
10253 uint64_t msg_ref = 0;
10254 msg_var = ChannelReestablish_clone(&msg_var);
10255 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10256 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10257 js_invoke_function_ubuuuu(j_calls->instance_ptr, 83, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10259 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
10260 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10261 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10262 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10263 LDKChannelUpdate msg_var = *msg;
10264 uint64_t msg_ref = 0;
10265 msg_var = ChannelUpdate_clone(&msg_var);
10266 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10267 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10268 js_invoke_function_ubuuuu(j_calls->instance_ptr, 84, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10270 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
10271 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10272 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10273 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10274 LDKErrorMessage msg_var = *msg;
10275 uint64_t msg_ref = 0;
10276 msg_var = ErrorMessage_clone(&msg_var);
10277 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10278 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10279 js_invoke_function_ubuuuu(j_calls->instance_ptr, 85, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10281 LDKNodeFeatures provided_node_features_LDKChannelMessageHandler_jcall(const void* this_arg) {
10282 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10283 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 86, 0, 0, 0, 0, 0, 0);
10284 LDKNodeFeatures ret_conv;
10285 ret_conv.inner = untag_ptr(ret);
10286 ret_conv.is_owned = ptr_is_owned(ret);
10287 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10290 LDKInitFeatures provided_init_features_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10291 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
10292 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10293 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10294 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 87, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10295 LDKInitFeatures ret_conv;
10296 ret_conv.inner = untag_ptr(ret);
10297 ret_conv.is_owned = ptr_is_owned(ret);
10298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10301 static void LDKChannelMessageHandler_JCalls_cloned(LDKChannelMessageHandler* new_obj) {
10302 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) new_obj->this_arg;
10303 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10304 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
10306 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
10307 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
10308 atomic_init(&calls->refcnt, 1);
10309 calls->instance_ptr = o;
10311 LDKChannelMessageHandler ret = {
10312 .this_arg = (void*) calls,
10313 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
10314 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
10315 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
10316 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
10317 .handle_channel_ready = handle_channel_ready_LDKChannelMessageHandler_jcall,
10318 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
10319 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
10320 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
10321 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
10322 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
10323 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
10324 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
10325 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
10326 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
10327 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
10328 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
10329 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
10330 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
10331 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
10332 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
10333 .provided_node_features = provided_node_features_LDKChannelMessageHandler_jcall,
10334 .provided_init_features = provided_init_features_LDKChannelMessageHandler_jcall,
10335 .free = LDKChannelMessageHandler_JCalls_free,
10336 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
10338 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
10341 uint64_t __attribute__((export_name("TS_LDKChannelMessageHandler_new"))) TS_LDKChannelMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
10342 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
10343 *res_ptr = LDKChannelMessageHandler_init(o, MessageSendEventsProvider);
10344 return tag_ptr(res_ptr, true);
10346 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) {
10347 void* this_arg_ptr = untag_ptr(this_arg);
10348 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10349 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10350 LDKPublicKey their_node_id_ref;
10351 CHECK(their_node_id->arr_len == 33);
10352 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10353 LDKOpenChannel msg_conv;
10354 msg_conv.inner = untag_ptr(msg);
10355 msg_conv.is_owned = ptr_is_owned(msg);
10356 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10357 msg_conv.is_owned = false;
10358 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10361 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) {
10362 void* this_arg_ptr = untag_ptr(this_arg);
10363 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10364 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10365 LDKPublicKey their_node_id_ref;
10366 CHECK(their_node_id->arr_len == 33);
10367 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10368 LDKAcceptChannel msg_conv;
10369 msg_conv.inner = untag_ptr(msg);
10370 msg_conv.is_owned = ptr_is_owned(msg);
10371 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10372 msg_conv.is_owned = false;
10373 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10376 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) {
10377 void* this_arg_ptr = untag_ptr(this_arg);
10378 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10379 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10380 LDKPublicKey their_node_id_ref;
10381 CHECK(their_node_id->arr_len == 33);
10382 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10383 LDKFundingCreated msg_conv;
10384 msg_conv.inner = untag_ptr(msg);
10385 msg_conv.is_owned = ptr_is_owned(msg);
10386 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10387 msg_conv.is_owned = false;
10388 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10391 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) {
10392 void* this_arg_ptr = untag_ptr(this_arg);
10393 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10394 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10395 LDKPublicKey their_node_id_ref;
10396 CHECK(their_node_id->arr_len == 33);
10397 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10398 LDKFundingSigned msg_conv;
10399 msg_conv.inner = untag_ptr(msg);
10400 msg_conv.is_owned = ptr_is_owned(msg);
10401 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10402 msg_conv.is_owned = false;
10403 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10406 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) {
10407 void* this_arg_ptr = untag_ptr(this_arg);
10408 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10409 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10410 LDKPublicKey their_node_id_ref;
10411 CHECK(their_node_id->arr_len == 33);
10412 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10413 LDKChannelReady msg_conv;
10414 msg_conv.inner = untag_ptr(msg);
10415 msg_conv.is_owned = ptr_is_owned(msg);
10416 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10417 msg_conv.is_owned = false;
10418 (this_arg_conv->handle_channel_ready)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10421 void __attribute__((export_name("TS_ChannelMessageHandler_handle_shutdown"))) TS_ChannelMessageHandler_handle_shutdown(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10422 void* this_arg_ptr = untag_ptr(this_arg);
10423 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10424 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10425 LDKPublicKey their_node_id_ref;
10426 CHECK(their_node_id->arr_len == 33);
10427 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10428 LDKShutdown msg_conv;
10429 msg_conv.inner = untag_ptr(msg);
10430 msg_conv.is_owned = ptr_is_owned(msg);
10431 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10432 msg_conv.is_owned = false;
10433 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10436 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) {
10437 void* this_arg_ptr = untag_ptr(this_arg);
10438 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10439 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10440 LDKPublicKey their_node_id_ref;
10441 CHECK(their_node_id->arr_len == 33);
10442 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10443 LDKClosingSigned msg_conv;
10444 msg_conv.inner = untag_ptr(msg);
10445 msg_conv.is_owned = ptr_is_owned(msg);
10446 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10447 msg_conv.is_owned = false;
10448 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10451 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) {
10452 void* this_arg_ptr = untag_ptr(this_arg);
10453 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10454 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10455 LDKPublicKey their_node_id_ref;
10456 CHECK(their_node_id->arr_len == 33);
10457 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10458 LDKUpdateAddHTLC msg_conv;
10459 msg_conv.inner = untag_ptr(msg);
10460 msg_conv.is_owned = ptr_is_owned(msg);
10461 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10462 msg_conv.is_owned = false;
10463 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10466 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) {
10467 void* this_arg_ptr = untag_ptr(this_arg);
10468 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10469 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10470 LDKPublicKey their_node_id_ref;
10471 CHECK(their_node_id->arr_len == 33);
10472 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10473 LDKUpdateFulfillHTLC msg_conv;
10474 msg_conv.inner = untag_ptr(msg);
10475 msg_conv.is_owned = ptr_is_owned(msg);
10476 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10477 msg_conv.is_owned = false;
10478 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10481 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) {
10482 void* this_arg_ptr = untag_ptr(this_arg);
10483 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10484 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10485 LDKPublicKey their_node_id_ref;
10486 CHECK(their_node_id->arr_len == 33);
10487 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10488 LDKUpdateFailHTLC msg_conv;
10489 msg_conv.inner = untag_ptr(msg);
10490 msg_conv.is_owned = ptr_is_owned(msg);
10491 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10492 msg_conv.is_owned = false;
10493 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10496 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) {
10497 void* this_arg_ptr = untag_ptr(this_arg);
10498 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10499 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10500 LDKPublicKey their_node_id_ref;
10501 CHECK(their_node_id->arr_len == 33);
10502 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10503 LDKUpdateFailMalformedHTLC msg_conv;
10504 msg_conv.inner = untag_ptr(msg);
10505 msg_conv.is_owned = ptr_is_owned(msg);
10506 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10507 msg_conv.is_owned = false;
10508 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10511 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) {
10512 void* this_arg_ptr = untag_ptr(this_arg);
10513 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10514 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10515 LDKPublicKey their_node_id_ref;
10516 CHECK(their_node_id->arr_len == 33);
10517 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10518 LDKCommitmentSigned msg_conv;
10519 msg_conv.inner = untag_ptr(msg);
10520 msg_conv.is_owned = ptr_is_owned(msg);
10521 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10522 msg_conv.is_owned = false;
10523 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10526 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) {
10527 void* this_arg_ptr = untag_ptr(this_arg);
10528 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10529 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10530 LDKPublicKey their_node_id_ref;
10531 CHECK(their_node_id->arr_len == 33);
10532 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10533 LDKRevokeAndACK msg_conv;
10534 msg_conv.inner = untag_ptr(msg);
10535 msg_conv.is_owned = ptr_is_owned(msg);
10536 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10537 msg_conv.is_owned = false;
10538 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10541 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) {
10542 void* this_arg_ptr = untag_ptr(this_arg);
10543 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10544 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10545 LDKPublicKey their_node_id_ref;
10546 CHECK(their_node_id->arr_len == 33);
10547 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10548 LDKUpdateFee msg_conv;
10549 msg_conv.inner = untag_ptr(msg);
10550 msg_conv.is_owned = ptr_is_owned(msg);
10551 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10552 msg_conv.is_owned = false;
10553 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10556 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) {
10557 void* this_arg_ptr = untag_ptr(this_arg);
10558 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10559 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10560 LDKPublicKey their_node_id_ref;
10561 CHECK(their_node_id->arr_len == 33);
10562 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10563 LDKAnnouncementSignatures msg_conv;
10564 msg_conv.inner = untag_ptr(msg);
10565 msg_conv.is_owned = ptr_is_owned(msg);
10566 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10567 msg_conv.is_owned = false;
10568 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10571 void __attribute__((export_name("TS_ChannelMessageHandler_peer_disconnected"))) TS_ChannelMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id) {
10572 void* this_arg_ptr = untag_ptr(this_arg);
10573 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10574 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10575 LDKPublicKey their_node_id_ref;
10576 CHECK(their_node_id->arr_len == 33);
10577 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10578 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref);
10581 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) {
10582 void* this_arg_ptr = untag_ptr(this_arg);
10583 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10584 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10585 LDKPublicKey their_node_id_ref;
10586 CHECK(their_node_id->arr_len == 33);
10587 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10589 msg_conv.inner = untag_ptr(msg);
10590 msg_conv.is_owned = ptr_is_owned(msg);
10591 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10592 msg_conv.is_owned = false;
10593 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
10594 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv, inbound);
10595 return tag_ptr(ret_conv, true);
10598 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) {
10599 void* this_arg_ptr = untag_ptr(this_arg);
10600 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10601 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10602 LDKPublicKey their_node_id_ref;
10603 CHECK(their_node_id->arr_len == 33);
10604 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10605 LDKChannelReestablish msg_conv;
10606 msg_conv.inner = untag_ptr(msg);
10607 msg_conv.is_owned = ptr_is_owned(msg);
10608 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10609 msg_conv.is_owned = false;
10610 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10613 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) {
10614 void* this_arg_ptr = untag_ptr(this_arg);
10615 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10616 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10617 LDKPublicKey their_node_id_ref;
10618 CHECK(their_node_id->arr_len == 33);
10619 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10620 LDKChannelUpdate msg_conv;
10621 msg_conv.inner = untag_ptr(msg);
10622 msg_conv.is_owned = ptr_is_owned(msg);
10623 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10624 msg_conv.is_owned = false;
10625 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10628 void __attribute__((export_name("TS_ChannelMessageHandler_handle_error"))) TS_ChannelMessageHandler_handle_error(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
10629 void* this_arg_ptr = untag_ptr(this_arg);
10630 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10631 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10632 LDKPublicKey their_node_id_ref;
10633 CHECK(their_node_id->arr_len == 33);
10634 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10635 LDKErrorMessage msg_conv;
10636 msg_conv.inner = untag_ptr(msg);
10637 msg_conv.is_owned = ptr_is_owned(msg);
10638 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10639 msg_conv.is_owned = false;
10640 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10643 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_node_features"))) TS_ChannelMessageHandler_provided_node_features(uint64_t this_arg) {
10644 void* this_arg_ptr = untag_ptr(this_arg);
10645 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10646 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10647 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
10648 uint64_t ret_ref = 0;
10649 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10650 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10654 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_init_features"))) TS_ChannelMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
10655 void* this_arg_ptr = untag_ptr(this_arg);
10656 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10657 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10658 LDKPublicKey their_node_id_ref;
10659 CHECK(their_node_id->arr_len == 33);
10660 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10661 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
10662 uint64_t ret_ref = 0;
10663 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10664 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10668 typedef struct LDKRoutingMessageHandler_JCalls {
10669 atomic_size_t refcnt;
10670 uint32_t instance_ptr;
10671 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
10672 } LDKRoutingMessageHandler_JCalls;
10673 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
10674 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10675 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10679 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
10680 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10681 LDKNodeAnnouncement msg_var = *msg;
10682 uint64_t msg_ref = 0;
10683 msg_var = NodeAnnouncement_clone(&msg_var);
10684 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10685 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10686 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 88, msg_ref, 0, 0, 0, 0, 0);
10687 void* ret_ptr = untag_ptr(ret);
10688 CHECK_ACCESS(ret_ptr);
10689 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10690 FREE(untag_ptr(ret));
10693 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
10694 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10695 LDKChannelAnnouncement msg_var = *msg;
10696 uint64_t msg_ref = 0;
10697 msg_var = ChannelAnnouncement_clone(&msg_var);
10698 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10699 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10700 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 89, msg_ref, 0, 0, 0, 0, 0);
10701 void* ret_ptr = untag_ptr(ret);
10702 CHECK_ACCESS(ret_ptr);
10703 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10704 FREE(untag_ptr(ret));
10707 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
10708 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10709 LDKChannelUpdate msg_var = *msg;
10710 uint64_t msg_ref = 0;
10711 msg_var = ChannelUpdate_clone(&msg_var);
10712 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10713 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10714 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 90, msg_ref, 0, 0, 0, 0, 0);
10715 void* ret_ptr = untag_ptr(ret);
10716 CHECK_ACCESS(ret_ptr);
10717 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10718 FREE(untag_ptr(ret));
10721 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point) {
10722 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10723 int64_t starting_point_conv = starting_point;
10724 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 91, starting_point_conv, 0, 0, 0, 0, 0);
10725 void* ret_ptr = untag_ptr(ret);
10726 CHECK_ACCESS(ret_ptr);
10727 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(ret_ptr);
10728 FREE(untag_ptr(ret));
10731 LDKNodeAnnouncement get_next_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKNodeId starting_point) {
10732 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10733 LDKNodeId starting_point_var = starting_point;
10734 uint64_t starting_point_ref = 0;
10735 CHECK_INNER_FIELD_ACCESS_OR_NULL(starting_point_var);
10736 starting_point_ref = tag_ptr(starting_point_var.inner, starting_point_var.is_owned);
10737 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 92, starting_point_ref, 0, 0, 0, 0, 0);
10738 LDKNodeAnnouncement ret_conv;
10739 ret_conv.inner = untag_ptr(ret);
10740 ret_conv.is_owned = ptr_is_owned(ret);
10741 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10744 LDKCResult_NoneNoneZ peer_connected_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init, bool inbound) {
10745 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10746 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10747 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10748 LDKInit init_var = *init;
10749 uint64_t init_ref = 0;
10750 init_var = Init_clone(&init_var);
10751 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
10752 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
10753 jboolean inbound_conv = inbound;
10754 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);
10755 void* ret_ptr = untag_ptr(ret);
10756 CHECK_ACCESS(ret_ptr);
10757 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
10758 FREE(untag_ptr(ret));
10761 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
10762 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10763 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10764 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10765 LDKReplyChannelRange msg_var = msg;
10766 uint64_t msg_ref = 0;
10767 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10768 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10769 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 94, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10770 void* ret_ptr = untag_ptr(ret);
10771 CHECK_ACCESS(ret_ptr);
10772 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10773 FREE(untag_ptr(ret));
10776 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
10777 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10778 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10779 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10780 LDKReplyShortChannelIdsEnd msg_var = msg;
10781 uint64_t msg_ref = 0;
10782 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10783 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10784 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 95, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10785 void* ret_ptr = untag_ptr(ret);
10786 CHECK_ACCESS(ret_ptr);
10787 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10788 FREE(untag_ptr(ret));
10791 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
10792 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10793 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10794 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10795 LDKQueryChannelRange msg_var = msg;
10796 uint64_t msg_ref = 0;
10797 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10798 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10799 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 96, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10800 void* ret_ptr = untag_ptr(ret);
10801 CHECK_ACCESS(ret_ptr);
10802 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10803 FREE(untag_ptr(ret));
10806 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
10807 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10808 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10809 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10810 LDKQueryShortChannelIds msg_var = msg;
10811 uint64_t msg_ref = 0;
10812 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10813 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
10814 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 97, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
10815 void* ret_ptr = untag_ptr(ret);
10816 CHECK_ACCESS(ret_ptr);
10817 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10818 FREE(untag_ptr(ret));
10821 bool processing_queue_high_LDKRoutingMessageHandler_jcall(const void* this_arg) {
10822 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10823 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 98, 0, 0, 0, 0, 0, 0);
10825 LDKNodeFeatures provided_node_features_LDKRoutingMessageHandler_jcall(const void* this_arg) {
10826 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10827 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 99, 0, 0, 0, 0, 0, 0);
10828 LDKNodeFeatures ret_conv;
10829 ret_conv.inner = untag_ptr(ret);
10830 ret_conv.is_owned = ptr_is_owned(ret);
10831 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10834 LDKInitFeatures provided_init_features_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
10835 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10836 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10837 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10838 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 100, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
10839 LDKInitFeatures ret_conv;
10840 ret_conv.inner = untag_ptr(ret);
10841 ret_conv.is_owned = ptr_is_owned(ret);
10842 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
10845 static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
10846 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) new_obj->this_arg;
10847 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10848 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
10850 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
10851 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
10852 atomic_init(&calls->refcnt, 1);
10853 calls->instance_ptr = o;
10855 LDKRoutingMessageHandler ret = {
10856 .this_arg = (void*) calls,
10857 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
10858 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
10859 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
10860 .get_next_channel_announcement = get_next_channel_announcement_LDKRoutingMessageHandler_jcall,
10861 .get_next_node_announcement = get_next_node_announcement_LDKRoutingMessageHandler_jcall,
10862 .peer_connected = peer_connected_LDKRoutingMessageHandler_jcall,
10863 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
10864 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
10865 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
10866 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
10867 .processing_queue_high = processing_queue_high_LDKRoutingMessageHandler_jcall,
10868 .provided_node_features = provided_node_features_LDKRoutingMessageHandler_jcall,
10869 .provided_init_features = provided_init_features_LDKRoutingMessageHandler_jcall,
10870 .free = LDKRoutingMessageHandler_JCalls_free,
10871 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
10873 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
10876 uint64_t __attribute__((export_name("TS_LDKRoutingMessageHandler_new"))) TS_LDKRoutingMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
10877 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
10878 *res_ptr = LDKRoutingMessageHandler_init(o, MessageSendEventsProvider);
10879 return tag_ptr(res_ptr, true);
10881 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_node_announcement"))) TS_RoutingMessageHandler_handle_node_announcement(uint64_t this_arg, uint64_t msg) {
10882 void* this_arg_ptr = untag_ptr(this_arg);
10883 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10884 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10885 LDKNodeAnnouncement msg_conv;
10886 msg_conv.inner = untag_ptr(msg);
10887 msg_conv.is_owned = ptr_is_owned(msg);
10888 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10889 msg_conv.is_owned = false;
10890 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10891 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
10892 return tag_ptr(ret_conv, true);
10895 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_announcement"))) TS_RoutingMessageHandler_handle_channel_announcement(uint64_t this_arg, uint64_t msg) {
10896 void* this_arg_ptr = untag_ptr(this_arg);
10897 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10898 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10899 LDKChannelAnnouncement msg_conv;
10900 msg_conv.inner = untag_ptr(msg);
10901 msg_conv.is_owned = ptr_is_owned(msg);
10902 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10903 msg_conv.is_owned = false;
10904 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10905 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
10906 return tag_ptr(ret_conv, true);
10909 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_update"))) TS_RoutingMessageHandler_handle_channel_update(uint64_t this_arg, uint64_t msg) {
10910 void* this_arg_ptr = untag_ptr(this_arg);
10911 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10912 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10913 LDKChannelUpdate msg_conv;
10914 msg_conv.inner = untag_ptr(msg);
10915 msg_conv.is_owned = ptr_is_owned(msg);
10916 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10917 msg_conv.is_owned = false;
10918 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10919 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
10920 return tag_ptr(ret_conv, true);
10923 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) {
10924 void* this_arg_ptr = untag_ptr(this_arg);
10925 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10926 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10927 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
10928 *ret_copy = (this_arg_conv->get_next_channel_announcement)(this_arg_conv->this_arg, starting_point);
10929 uint64_t ret_ref = tag_ptr(ret_copy, true);
10933 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) {
10934 void* this_arg_ptr = untag_ptr(this_arg);
10935 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10936 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10937 LDKNodeId starting_point_conv;
10938 starting_point_conv.inner = untag_ptr(starting_point);
10939 starting_point_conv.is_owned = ptr_is_owned(starting_point);
10940 CHECK_INNER_FIELD_ACCESS_OR_NULL(starting_point_conv);
10941 starting_point_conv = NodeId_clone(&starting_point_conv);
10942 LDKNodeAnnouncement ret_var = (this_arg_conv->get_next_node_announcement)(this_arg_conv->this_arg, starting_point_conv);
10943 uint64_t ret_ref = 0;
10944 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10945 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10949 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) {
10950 void* this_arg_ptr = untag_ptr(this_arg);
10951 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10952 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10953 LDKPublicKey their_node_id_ref;
10954 CHECK(their_node_id->arr_len == 33);
10955 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10957 init_conv.inner = untag_ptr(init);
10958 init_conv.is_owned = ptr_is_owned(init);
10959 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
10960 init_conv.is_owned = false;
10961 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
10962 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv, inbound);
10963 return tag_ptr(ret_conv, true);
10966 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) {
10967 void* this_arg_ptr = untag_ptr(this_arg);
10968 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10969 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10970 LDKPublicKey their_node_id_ref;
10971 CHECK(their_node_id->arr_len == 33);
10972 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10973 LDKReplyChannelRange msg_conv;
10974 msg_conv.inner = untag_ptr(msg);
10975 msg_conv.is_owned = ptr_is_owned(msg);
10976 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10977 msg_conv = ReplyChannelRange_clone(&msg_conv);
10978 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10979 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10980 return tag_ptr(ret_conv, true);
10983 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) {
10984 void* this_arg_ptr = untag_ptr(this_arg);
10985 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
10986 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10987 LDKPublicKey their_node_id_ref;
10988 CHECK(their_node_id->arr_len == 33);
10989 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10990 LDKReplyShortChannelIdsEnd msg_conv;
10991 msg_conv.inner = untag_ptr(msg);
10992 msg_conv.is_owned = ptr_is_owned(msg);
10993 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10994 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
10995 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10996 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10997 return tag_ptr(ret_conv, true);
11000 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) {
11001 void* this_arg_ptr = untag_ptr(this_arg);
11002 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11003 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11004 LDKPublicKey their_node_id_ref;
11005 CHECK(their_node_id->arr_len == 33);
11006 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11007 LDKQueryChannelRange msg_conv;
11008 msg_conv.inner = untag_ptr(msg);
11009 msg_conv.is_owned = ptr_is_owned(msg);
11010 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
11011 msg_conv = QueryChannelRange_clone(&msg_conv);
11012 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11013 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
11014 return tag_ptr(ret_conv, true);
11017 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) {
11018 void* this_arg_ptr = untag_ptr(this_arg);
11019 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11020 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11021 LDKPublicKey their_node_id_ref;
11022 CHECK(their_node_id->arr_len == 33);
11023 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11024 LDKQueryShortChannelIds msg_conv;
11025 msg_conv.inner = untag_ptr(msg);
11026 msg_conv.is_owned = ptr_is_owned(msg);
11027 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
11028 msg_conv = QueryShortChannelIds_clone(&msg_conv);
11029 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11030 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
11031 return tag_ptr(ret_conv, true);
11034 jboolean __attribute__((export_name("TS_RoutingMessageHandler_processing_queue_high"))) TS_RoutingMessageHandler_processing_queue_high(uint64_t this_arg) {
11035 void* this_arg_ptr = untag_ptr(this_arg);
11036 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11037 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11038 jboolean ret_conv = (this_arg_conv->processing_queue_high)(this_arg_conv->this_arg);
11042 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_node_features"))) TS_RoutingMessageHandler_provided_node_features(uint64_t this_arg) {
11043 void* this_arg_ptr = untag_ptr(this_arg);
11044 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11045 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11046 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
11047 uint64_t ret_ref = 0;
11048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11049 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11053 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_init_features"))) TS_RoutingMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
11054 void* this_arg_ptr = untag_ptr(this_arg);
11055 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11056 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
11057 LDKPublicKey their_node_id_ref;
11058 CHECK(their_node_id->arr_len == 33);
11059 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11060 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
11061 uint64_t ret_ref = 0;
11062 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11063 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11067 typedef struct LDKOnionMessageProvider_JCalls {
11068 atomic_size_t refcnt;
11069 uint32_t instance_ptr;
11070 } LDKOnionMessageProvider_JCalls;
11071 static void LDKOnionMessageProvider_JCalls_free(void* this_arg) {
11072 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
11073 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11077 LDKOnionMessage next_onion_message_for_peer_LDKOnionMessageProvider_jcall(const void* this_arg, LDKPublicKey peer_node_id) {
11078 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
11079 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
11080 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
11081 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 101, (uint32_t)peer_node_id_arr, 0, 0, 0, 0, 0);
11082 LDKOnionMessage ret_conv;
11083 ret_conv.inner = untag_ptr(ret);
11084 ret_conv.is_owned = ptr_is_owned(ret);
11085 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11088 static void LDKOnionMessageProvider_JCalls_cloned(LDKOnionMessageProvider* new_obj) {
11089 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) new_obj->this_arg;
11090 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11092 static inline LDKOnionMessageProvider LDKOnionMessageProvider_init (JSValue o) {
11093 LDKOnionMessageProvider_JCalls *calls = MALLOC(sizeof(LDKOnionMessageProvider_JCalls), "LDKOnionMessageProvider_JCalls");
11094 atomic_init(&calls->refcnt, 1);
11095 calls->instance_ptr = o;
11097 LDKOnionMessageProvider ret = {
11098 .this_arg = (void*) calls,
11099 .next_onion_message_for_peer = next_onion_message_for_peer_LDKOnionMessageProvider_jcall,
11100 .free = LDKOnionMessageProvider_JCalls_free,
11104 uint64_t __attribute__((export_name("TS_LDKOnionMessageProvider_new"))) TS_LDKOnionMessageProvider_new(JSValue o) {
11105 LDKOnionMessageProvider *res_ptr = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
11106 *res_ptr = LDKOnionMessageProvider_init(o);
11107 return tag_ptr(res_ptr, true);
11109 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) {
11110 void* this_arg_ptr = untag_ptr(this_arg);
11111 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11112 LDKOnionMessageProvider* this_arg_conv = (LDKOnionMessageProvider*)this_arg_ptr;
11113 LDKPublicKey peer_node_id_ref;
11114 CHECK(peer_node_id->arr_len == 33);
11115 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
11116 LDKOnionMessage ret_var = (this_arg_conv->next_onion_message_for_peer)(this_arg_conv->this_arg, peer_node_id_ref);
11117 uint64_t ret_ref = 0;
11118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11119 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11123 typedef struct LDKOnionMessageHandler_JCalls {
11124 atomic_size_t refcnt;
11125 uint32_t instance_ptr;
11126 LDKOnionMessageProvider_JCalls* OnionMessageProvider;
11127 } LDKOnionMessageHandler_JCalls;
11128 static void LDKOnionMessageHandler_JCalls_free(void* this_arg) {
11129 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11130 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11134 void handle_onion_message_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey peer_node_id, const LDKOnionMessage * msg) {
11135 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11136 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
11137 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
11138 LDKOnionMessage msg_var = *msg;
11139 uint64_t msg_ref = 0;
11140 msg_var = OnionMessage_clone(&msg_var);
11141 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
11142 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
11143 js_invoke_function_ubuuuu(j_calls->instance_ptr, 102, (uint32_t)peer_node_id_arr, msg_ref, 0, 0, 0, 0);
11145 LDKCResult_NoneNoneZ peer_connected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init, bool inbound) {
11146 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11147 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
11148 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
11149 LDKInit init_var = *init;
11150 uint64_t init_ref = 0;
11151 init_var = Init_clone(&init_var);
11152 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
11153 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
11154 jboolean inbound_conv = inbound;
11155 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);
11156 void* ret_ptr = untag_ptr(ret);
11157 CHECK_ACCESS(ret_ptr);
11158 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
11159 FREE(untag_ptr(ret));
11162 void peer_disconnected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
11163 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11164 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
11165 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
11166 js_invoke_function_uuuuuu(j_calls->instance_ptr, 104, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
11168 LDKNodeFeatures provided_node_features_LDKOnionMessageHandler_jcall(const void* this_arg) {
11169 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11170 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 105, 0, 0, 0, 0, 0, 0);
11171 LDKNodeFeatures ret_conv;
11172 ret_conv.inner = untag_ptr(ret);
11173 ret_conv.is_owned = ptr_is_owned(ret);
11174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11177 LDKInitFeatures provided_init_features_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
11178 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
11179 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
11180 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
11181 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 106, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
11182 LDKInitFeatures ret_conv;
11183 ret_conv.inner = untag_ptr(ret);
11184 ret_conv.is_owned = ptr_is_owned(ret);
11185 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
11188 static void LDKOnionMessageHandler_JCalls_cloned(LDKOnionMessageHandler* new_obj) {
11189 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) new_obj->this_arg;
11190 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11191 atomic_fetch_add_explicit(&j_calls->OnionMessageProvider->refcnt, 1, memory_order_release);
11193 static inline LDKOnionMessageHandler LDKOnionMessageHandler_init (JSValue o, JSValue OnionMessageProvider) {
11194 LDKOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKOnionMessageHandler_JCalls), "LDKOnionMessageHandler_JCalls");
11195 atomic_init(&calls->refcnt, 1);
11196 calls->instance_ptr = o;
11198 LDKOnionMessageHandler ret = {
11199 .this_arg = (void*) calls,
11200 .handle_onion_message = handle_onion_message_LDKOnionMessageHandler_jcall,
11201 .peer_connected = peer_connected_LDKOnionMessageHandler_jcall,
11202 .peer_disconnected = peer_disconnected_LDKOnionMessageHandler_jcall,
11203 .provided_node_features = provided_node_features_LDKOnionMessageHandler_jcall,
11204 .provided_init_features = provided_init_features_LDKOnionMessageHandler_jcall,
11205 .free = LDKOnionMessageHandler_JCalls_free,
11206 .OnionMessageProvider = LDKOnionMessageProvider_init(OnionMessageProvider),
11208 calls->OnionMessageProvider = ret.OnionMessageProvider.this_arg;
11211 uint64_t __attribute__((export_name("TS_LDKOnionMessageHandler_new"))) TS_LDKOnionMessageHandler_new(JSValue o, JSValue OnionMessageProvider) {
11212 LDKOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
11213 *res_ptr = LDKOnionMessageHandler_init(o, OnionMessageProvider);
11214 return tag_ptr(res_ptr, true);
11216 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) {
11217 void* this_arg_ptr = untag_ptr(this_arg);
11218 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11219 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11220 LDKPublicKey peer_node_id_ref;
11221 CHECK(peer_node_id->arr_len == 33);
11222 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
11223 LDKOnionMessage msg_conv;
11224 msg_conv.inner = untag_ptr(msg);
11225 msg_conv.is_owned = ptr_is_owned(msg);
11226 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
11227 msg_conv.is_owned = false;
11228 (this_arg_conv->handle_onion_message)(this_arg_conv->this_arg, peer_node_id_ref, &msg_conv);
11231 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) {
11232 void* this_arg_ptr = untag_ptr(this_arg);
11233 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11234 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11235 LDKPublicKey their_node_id_ref;
11236 CHECK(their_node_id->arr_len == 33);
11237 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11239 init_conv.inner = untag_ptr(init);
11240 init_conv.is_owned = ptr_is_owned(init);
11241 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
11242 init_conv.is_owned = false;
11243 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11244 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv, inbound);
11245 return tag_ptr(ret_conv, true);
11248 void __attribute__((export_name("TS_OnionMessageHandler_peer_disconnected"))) TS_OnionMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id) {
11249 void* this_arg_ptr = untag_ptr(this_arg);
11250 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11251 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11252 LDKPublicKey their_node_id_ref;
11253 CHECK(their_node_id->arr_len == 33);
11254 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11255 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref);
11258 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_node_features"))) TS_OnionMessageHandler_provided_node_features(uint64_t this_arg) {
11259 void* this_arg_ptr = untag_ptr(this_arg);
11260 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11261 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11262 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
11263 uint64_t ret_ref = 0;
11264 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11265 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11269 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_init_features"))) TS_OnionMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
11270 void* this_arg_ptr = untag_ptr(this_arg);
11271 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11272 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
11273 LDKPublicKey their_node_id_ref;
11274 CHECK(their_node_id->arr_len == 33);
11275 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
11276 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
11277 uint64_t ret_ref = 0;
11278 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11279 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11283 typedef struct LDKCustomMessageReader_JCalls {
11284 atomic_size_t refcnt;
11285 uint32_t instance_ptr;
11286 } LDKCustomMessageReader_JCalls;
11287 static void LDKCustomMessageReader_JCalls_free(void* this_arg) {
11288 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
11289 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11293 LDKCResult_COption_TypeZDecodeErrorZ read_LDKCustomMessageReader_jcall(const void* this_arg, uint16_t message_type, LDKu8slice buffer) {
11294 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
11295 int16_t message_type_conv = message_type;
11296 LDKu8slice buffer_var = buffer;
11297 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
11298 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
11299 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 107, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
11300 void* ret_ptr = untag_ptr(ret);
11301 CHECK_ACCESS(ret_ptr);
11302 LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
11303 FREE(untag_ptr(ret));
11306 static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
11307 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) new_obj->this_arg;
11308 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11310 static inline LDKCustomMessageReader LDKCustomMessageReader_init (JSValue o) {
11311 LDKCustomMessageReader_JCalls *calls = MALLOC(sizeof(LDKCustomMessageReader_JCalls), "LDKCustomMessageReader_JCalls");
11312 atomic_init(&calls->refcnt, 1);
11313 calls->instance_ptr = o;
11315 LDKCustomMessageReader ret = {
11316 .this_arg = (void*) calls,
11317 .read = read_LDKCustomMessageReader_jcall,
11318 .free = LDKCustomMessageReader_JCalls_free,
11322 uint64_t __attribute__((export_name("TS_LDKCustomMessageReader_new"))) TS_LDKCustomMessageReader_new(JSValue o) {
11323 LDKCustomMessageReader *res_ptr = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
11324 *res_ptr = LDKCustomMessageReader_init(o);
11325 return tag_ptr(res_ptr, true);
11327 uint64_t __attribute__((export_name("TS_CustomMessageReader_read"))) TS_CustomMessageReader_read(uint64_t this_arg, int16_t message_type, int8_tArray buffer) {
11328 void* this_arg_ptr = untag_ptr(this_arg);
11329 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11330 LDKCustomMessageReader* this_arg_conv = (LDKCustomMessageReader*)this_arg_ptr;
11331 LDKu8slice buffer_ref;
11332 buffer_ref.datalen = buffer->arr_len;
11333 buffer_ref.data = buffer->elems;
11334 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
11335 *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, message_type, buffer_ref);
11337 return tag_ptr(ret_conv, true);
11340 typedef struct LDKCustomMessageHandler_JCalls {
11341 atomic_size_t refcnt;
11342 uint32_t instance_ptr;
11343 LDKCustomMessageReader_JCalls* CustomMessageReader;
11344 } LDKCustomMessageHandler_JCalls;
11345 static void LDKCustomMessageHandler_JCalls_free(void* this_arg) {
11346 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
11347 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11351 LDKCResult_NoneLightningErrorZ handle_custom_message_LDKCustomMessageHandler_jcall(const void* this_arg, LDKType msg, LDKPublicKey sender_node_id) {
11352 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
11353 LDKType* msg_ret = MALLOC(sizeof(LDKType), "LDKType");
11355 int8_tArray sender_node_id_arr = init_int8_tArray(33, __LINE__);
11356 memcpy(sender_node_id_arr->elems, sender_node_id.compressed_form, 33);
11357 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);
11358 void* ret_ptr = untag_ptr(ret);
11359 CHECK_ACCESS(ret_ptr);
11360 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
11361 FREE(untag_ptr(ret));
11364 LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
11365 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
11366 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 109, 0, 0, 0, 0, 0, 0);
11367 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_constr;
11368 ret_constr.datalen = ret->arr_len;
11369 if (ret_constr.datalen > 0)
11370 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
11372 ret_constr.data = NULL;
11373 uint64_t* ret_vals = ret->elems;
11374 for (size_t z = 0; z < ret_constr.datalen; z++) {
11375 uint64_t ret_conv_25 = ret_vals[z];
11376 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
11377 CHECK_ACCESS(ret_conv_25_ptr);
11378 LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
11379 FREE(untag_ptr(ret_conv_25));
11380 ret_constr.data[z] = ret_conv_25_conv;
11385 static void LDKCustomMessageHandler_JCalls_cloned(LDKCustomMessageHandler* new_obj) {
11386 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) new_obj->this_arg;
11387 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11388 atomic_fetch_add_explicit(&j_calls->CustomMessageReader->refcnt, 1, memory_order_release);
11390 static inline LDKCustomMessageHandler LDKCustomMessageHandler_init (JSValue o, JSValue CustomMessageReader) {
11391 LDKCustomMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomMessageHandler_JCalls), "LDKCustomMessageHandler_JCalls");
11392 atomic_init(&calls->refcnt, 1);
11393 calls->instance_ptr = o;
11395 LDKCustomMessageHandler ret = {
11396 .this_arg = (void*) calls,
11397 .handle_custom_message = handle_custom_message_LDKCustomMessageHandler_jcall,
11398 .get_and_clear_pending_msg = get_and_clear_pending_msg_LDKCustomMessageHandler_jcall,
11399 .free = LDKCustomMessageHandler_JCalls_free,
11400 .CustomMessageReader = LDKCustomMessageReader_init(CustomMessageReader),
11402 calls->CustomMessageReader = ret.CustomMessageReader.this_arg;
11405 uint64_t __attribute__((export_name("TS_LDKCustomMessageHandler_new"))) TS_LDKCustomMessageHandler_new(JSValue o, JSValue CustomMessageReader) {
11406 LDKCustomMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
11407 *res_ptr = LDKCustomMessageHandler_init(o, CustomMessageReader);
11408 return tag_ptr(res_ptr, true);
11410 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) {
11411 void* this_arg_ptr = untag_ptr(this_arg);
11412 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11413 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
11414 void* msg_ptr = untag_ptr(msg);
11415 CHECK_ACCESS(msg_ptr);
11416 LDKType msg_conv = *(LDKType*)(msg_ptr);
11417 if (msg_conv.free == LDKType_JCalls_free) {
11418 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11419 LDKType_JCalls_cloned(&msg_conv);
11421 LDKPublicKey sender_node_id_ref;
11422 CHECK(sender_node_id->arr_len == 33);
11423 memcpy(sender_node_id_ref.compressed_form, sender_node_id->elems, 33); FREE(sender_node_id);
11424 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
11425 *ret_conv = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv, sender_node_id_ref);
11426 return tag_ptr(ret_conv, true);
11429 uint64_tArray __attribute__((export_name("TS_CustomMessageHandler_get_and_clear_pending_msg"))) TS_CustomMessageHandler_get_and_clear_pending_msg(uint64_t this_arg) {
11430 void* this_arg_ptr = untag_ptr(this_arg);
11431 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11432 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
11433 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_var = (this_arg_conv->get_and_clear_pending_msg)(this_arg_conv->this_arg);
11434 uint64_tArray ret_arr = NULL;
11435 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
11436 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
11437 for (size_t z = 0; z < ret_var.datalen; z++) {
11438 LDKC2Tuple_PublicKeyTypeZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
11439 *ret_conv_25_conv = ret_var.data[z];
11440 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
11443 FREE(ret_var.data);
11447 typedef struct LDKCustomOnionMessageHandler_JCalls {
11448 atomic_size_t refcnt;
11449 uint32_t instance_ptr;
11450 } LDKCustomOnionMessageHandler_JCalls;
11451 static void LDKCustomOnionMessageHandler_JCalls_free(void* this_arg) {
11452 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
11453 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11457 void handle_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, LDKCustomOnionMessageContents msg) {
11458 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
11459 LDKCustomOnionMessageContents* msg_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
11461 js_invoke_function_buuuuu(j_calls->instance_ptr, 110, tag_ptr(msg_ret, true), 0, 0, 0, 0, 0);
11463 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, uint64_t message_type, LDKu8slice buffer) {
11464 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
11465 int64_t message_type_conv = message_type;
11466 LDKu8slice buffer_var = buffer;
11467 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
11468 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
11469 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 111, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
11470 void* ret_ptr = untag_ptr(ret);
11471 CHECK_ACCESS(ret_ptr);
11472 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(ret_ptr);
11473 FREE(untag_ptr(ret));
11476 static void LDKCustomOnionMessageHandler_JCalls_cloned(LDKCustomOnionMessageHandler* new_obj) {
11477 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) new_obj->this_arg;
11478 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11480 static inline LDKCustomOnionMessageHandler LDKCustomOnionMessageHandler_init (JSValue o) {
11481 LDKCustomOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageHandler_JCalls), "LDKCustomOnionMessageHandler_JCalls");
11482 atomic_init(&calls->refcnt, 1);
11483 calls->instance_ptr = o;
11485 LDKCustomOnionMessageHandler ret = {
11486 .this_arg = (void*) calls,
11487 .handle_custom_message = handle_custom_message_LDKCustomOnionMessageHandler_jcall,
11488 .read_custom_message = read_custom_message_LDKCustomOnionMessageHandler_jcall,
11489 .free = LDKCustomOnionMessageHandler_JCalls_free,
11493 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageHandler_new"))) TS_LDKCustomOnionMessageHandler_new(JSValue o) {
11494 LDKCustomOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
11495 *res_ptr = LDKCustomOnionMessageHandler_init(o);
11496 return tag_ptr(res_ptr, true);
11498 void __attribute__((export_name("TS_CustomOnionMessageHandler_handle_custom_message"))) TS_CustomOnionMessageHandler_handle_custom_message(uint64_t this_arg, uint64_t msg) {
11499 void* this_arg_ptr = untag_ptr(this_arg);
11500 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11501 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
11502 void* msg_ptr = untag_ptr(msg);
11503 CHECK_ACCESS(msg_ptr);
11504 LDKCustomOnionMessageContents msg_conv = *(LDKCustomOnionMessageContents*)(msg_ptr);
11505 if (msg_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
11506 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11507 LDKCustomOnionMessageContents_JCalls_cloned(&msg_conv);
11509 (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv);
11512 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) {
11513 void* this_arg_ptr = untag_ptr(this_arg);
11514 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11515 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
11516 LDKu8slice buffer_ref;
11517 buffer_ref.datalen = buffer->arr_len;
11518 buffer_ref.data = buffer->elems;
11519 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
11520 *ret_conv = (this_arg_conv->read_custom_message)(this_arg_conv->this_arg, message_type, buffer_ref);
11522 return tag_ptr(ret_conv, true);
11525 typedef struct LDKSocketDescriptor_JCalls {
11526 atomic_size_t refcnt;
11527 uint32_t instance_ptr;
11528 } LDKSocketDescriptor_JCalls;
11529 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
11530 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11531 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11535 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
11536 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11537 LDKu8slice data_var = data;
11538 int8_tArray data_arr = init_int8_tArray(data_var.datalen, __LINE__);
11539 memcpy(data_arr->elems, data_var.data, data_var.datalen);
11540 jboolean resume_read_conv = resume_read;
11541 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 112, (uint32_t)data_arr, resume_read_conv, 0, 0, 0, 0);
11543 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
11544 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11545 js_invoke_function_uuuuuu(j_calls->instance_ptr, 113, 0, 0, 0, 0, 0, 0);
11547 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
11548 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11549 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
11550 *other_arg_clone = SocketDescriptor_clone(other_arg);
11551 return js_invoke_function_buuuuu(j_calls->instance_ptr, 114, tag_ptr(other_arg_clone, true), 0, 0, 0, 0, 0);
11553 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
11554 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
11555 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 115, 0, 0, 0, 0, 0, 0);
11557 static void LDKSocketDescriptor_JCalls_cloned(LDKSocketDescriptor* new_obj) {
11558 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) new_obj->this_arg;
11559 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11561 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JSValue o) {
11562 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
11563 atomic_init(&calls->refcnt, 1);
11564 calls->instance_ptr = o;
11566 LDKSocketDescriptor ret = {
11567 .this_arg = (void*) calls,
11568 .send_data = send_data_LDKSocketDescriptor_jcall,
11569 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
11570 .eq = eq_LDKSocketDescriptor_jcall,
11571 .hash = hash_LDKSocketDescriptor_jcall,
11572 .cloned = LDKSocketDescriptor_JCalls_cloned,
11573 .free = LDKSocketDescriptor_JCalls_free,
11577 uint64_t __attribute__((export_name("TS_LDKSocketDescriptor_new"))) TS_LDKSocketDescriptor_new(JSValue o) {
11578 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
11579 *res_ptr = LDKSocketDescriptor_init(o);
11580 return tag_ptr(res_ptr, true);
11582 uint32_t __attribute__((export_name("TS_SocketDescriptor_send_data"))) TS_SocketDescriptor_send_data(uint64_t this_arg, int8_tArray data, jboolean resume_read) {
11583 void* this_arg_ptr = untag_ptr(this_arg);
11584 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11585 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
11586 LDKu8slice data_ref;
11587 data_ref.datalen = data->arr_len;
11588 data_ref.data = data->elems;
11589 uint32_t ret_conv = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
11594 void __attribute__((export_name("TS_SocketDescriptor_disconnect_socket"))) TS_SocketDescriptor_disconnect_socket(uint64_t this_arg) {
11595 void* this_arg_ptr = untag_ptr(this_arg);
11596 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11597 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
11598 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
11601 int64_t __attribute__((export_name("TS_SocketDescriptor_hash"))) TS_SocketDescriptor_hash(uint64_t this_arg) {
11602 void* this_arg_ptr = untag_ptr(this_arg);
11603 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11604 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
11605 int64_t ret_conv = (this_arg_conv->hash)(this_arg_conv->this_arg);
11609 uint32_t __attribute__((export_name("TS_LDKEffectiveCapacity_ty_from_ptr"))) TS_LDKEffectiveCapacity_ty_from_ptr(uint64_t ptr) {
11610 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11612 case LDKEffectiveCapacity_ExactLiquidity: return 0;
11613 case LDKEffectiveCapacity_MaximumHTLC: return 1;
11614 case LDKEffectiveCapacity_Total: return 2;
11615 case LDKEffectiveCapacity_Infinite: return 3;
11616 case LDKEffectiveCapacity_Unknown: return 4;
11620 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat"))) TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(uint64_t ptr) {
11621 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11622 assert(obj->tag == LDKEffectiveCapacity_ExactLiquidity);
11623 int64_t liquidity_msat_conv = obj->exact_liquidity.liquidity_msat;
11624 return liquidity_msat_conv;
11626 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat"))) TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(uint64_t ptr) {
11627 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11628 assert(obj->tag == LDKEffectiveCapacity_MaximumHTLC);
11629 int64_t amount_msat_conv = obj->maximum_htlc.amount_msat;
11630 return amount_msat_conv;
11632 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_capacity_msat"))) TS_LDKEffectiveCapacity_Total_get_capacity_msat(uint64_t ptr) {
11633 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11634 assert(obj->tag == LDKEffectiveCapacity_Total);
11635 int64_t capacity_msat_conv = obj->total.capacity_msat;
11636 return capacity_msat_conv;
11638 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat"))) TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(uint64_t ptr) {
11639 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
11640 assert(obj->tag == LDKEffectiveCapacity_Total);
11641 int64_t htlc_maximum_msat_conv = obj->total.htlc_maximum_msat;
11642 return htlc_maximum_msat_conv;
11644 uint32_t __attribute__((export_name("TS_LDKHints_ty_from_ptr"))) TS_LDKHints_ty_from_ptr(uint64_t ptr) {
11645 LDKHints *obj = (LDKHints*)untag_ptr(ptr);
11647 case LDKHints_Blinded: return 0;
11648 case LDKHints_Clear: return 1;
11652 uint64_tArray __attribute__((export_name("TS_LDKHints_Blinded_get_blinded"))) TS_LDKHints_Blinded_get_blinded(uint64_t ptr) {
11653 LDKHints *obj = (LDKHints*)untag_ptr(ptr);
11654 assert(obj->tag == LDKHints_Blinded);
11655 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_var = obj->blinded;
11656 uint64_tArray blinded_arr = NULL;
11657 blinded_arr = init_uint64_tArray(blinded_var.datalen, __LINE__);
11658 uint64_t *blinded_arr_ptr = (uint64_t*)(((uint8_t*)blinded_arr) + 8);
11659 for (size_t l = 0; l < blinded_var.datalen; l++) {
11660 LDKC2Tuple_BlindedPayInfoBlindedPathZ* blinded_conv_37_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
11661 *blinded_conv_37_conv = blinded_var.data[l];
11662 *blinded_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(blinded_conv_37_conv);
11663 blinded_arr_ptr[l] = tag_ptr(blinded_conv_37_conv, true);
11666 return blinded_arr;
11668 uint64_tArray __attribute__((export_name("TS_LDKHints_Clear_get_clear"))) TS_LDKHints_Clear_get_clear(uint64_t ptr) {
11669 LDKHints *obj = (LDKHints*)untag_ptr(ptr);
11670 assert(obj->tag == LDKHints_Clear);
11671 LDKCVec_RouteHintZ clear_var = obj->clear;
11672 uint64_tArray clear_arr = NULL;
11673 clear_arr = init_uint64_tArray(clear_var.datalen, __LINE__);
11674 uint64_t *clear_arr_ptr = (uint64_t*)(((uint8_t*)clear_arr) + 8);
11675 for (size_t l = 0; l < clear_var.datalen; l++) {
11676 LDKRouteHint clear_conv_11_var = clear_var.data[l];
11677 uint64_t clear_conv_11_ref = 0;
11678 CHECK_INNER_FIELD_ACCESS_OR_NULL(clear_conv_11_var);
11679 clear_conv_11_ref = tag_ptr(clear_conv_11_var.inner, false);
11680 clear_arr_ptr[l] = clear_conv_11_ref;
11685 uint32_t __attribute__((export_name("TS_LDKDestination_ty_from_ptr"))) TS_LDKDestination_ty_from_ptr(uint64_t ptr) {
11686 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11688 case LDKDestination_Node: return 0;
11689 case LDKDestination_BlindedPath: return 1;
11693 int8_tArray __attribute__((export_name("TS_LDKDestination_Node_get_node"))) TS_LDKDestination_Node_get_node(uint64_t ptr) {
11694 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11695 assert(obj->tag == LDKDestination_Node);
11696 int8_tArray node_arr = init_int8_tArray(33, __LINE__);
11697 memcpy(node_arr->elems, obj->node.compressed_form, 33);
11700 uint64_t __attribute__((export_name("TS_LDKDestination_BlindedPath_get_blinded_path"))) TS_LDKDestination_BlindedPath_get_blinded_path(uint64_t ptr) {
11701 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
11702 assert(obj->tag == LDKDestination_BlindedPath);
11703 LDKBlindedPath blinded_path_var = obj->blinded_path;
11704 uint64_t blinded_path_ref = 0;
11705 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_path_var);
11706 blinded_path_ref = tag_ptr(blinded_path_var.inner, false);
11707 return blinded_path_ref;
11709 uint32_t __attribute__((export_name("TS_LDKOnionMessageContents_ty_from_ptr"))) TS_LDKOnionMessageContents_ty_from_ptr(uint64_t ptr) {
11710 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
11712 case LDKOnionMessageContents_Custom: return 0;
11716 uint64_t __attribute__((export_name("TS_LDKOnionMessageContents_Custom_get_custom"))) TS_LDKOnionMessageContents_Custom_get_custom(uint64_t ptr) {
11717 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
11718 assert(obj->tag == LDKOnionMessageContents_Custom);
11719 LDKCustomOnionMessageContents* custom_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
11720 *custom_ret = CustomOnionMessageContents_clone(&obj->custom);
11721 return tag_ptr(custom_ret, true);
11723 uint32_t __attribute__((export_name("TS_LDKGossipSync_ty_from_ptr"))) TS_LDKGossipSync_ty_from_ptr(uint64_t ptr) {
11724 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
11726 case LDKGossipSync_P2P: return 0;
11727 case LDKGossipSync_Rapid: return 1;
11728 case LDKGossipSync_None: return 2;
11732 uint64_t __attribute__((export_name("TS_LDKGossipSync_P2P_get_p2p"))) TS_LDKGossipSync_P2P_get_p2p(uint64_t ptr) {
11733 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
11734 assert(obj->tag == LDKGossipSync_P2P);
11735 LDKP2PGossipSync p2p_var = obj->p2p;
11736 uint64_t p2p_ref = 0;
11737 CHECK_INNER_FIELD_ACCESS_OR_NULL(p2p_var);
11738 p2p_ref = tag_ptr(p2p_var.inner, false);
11741 uint64_t __attribute__((export_name("TS_LDKGossipSync_Rapid_get_rapid"))) TS_LDKGossipSync_Rapid_get_rapid(uint64_t ptr) {
11742 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
11743 assert(obj->tag == LDKGossipSync_Rapid);
11744 LDKRapidGossipSync rapid_var = obj->rapid;
11745 uint64_t rapid_ref = 0;
11746 CHECK_INNER_FIELD_ACCESS_OR_NULL(rapid_var);
11747 rapid_ref = tag_ptr(rapid_var.inner, false);
11750 uint32_t __attribute__((export_name("TS_LDKFallback_ty_from_ptr"))) TS_LDKFallback_ty_from_ptr(uint64_t ptr) {
11751 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11753 case LDKFallback_SegWitProgram: return 0;
11754 case LDKFallback_PubKeyHash: return 1;
11755 case LDKFallback_ScriptHash: return 2;
11759 int8_t __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_version"))) TS_LDKFallback_SegWitProgram_get_version(uint64_t ptr) {
11760 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11761 assert(obj->tag == LDKFallback_SegWitProgram);
11762 uint8_t version_val = obj->seg_wit_program.version._0;
11763 return version_val;
11765 int8_tArray __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_program"))) TS_LDKFallback_SegWitProgram_get_program(uint64_t ptr) {
11766 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11767 assert(obj->tag == LDKFallback_SegWitProgram);
11768 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
11769 int8_tArray program_arr = init_int8_tArray(program_var.datalen, __LINE__);
11770 memcpy(program_arr->elems, program_var.data, program_var.datalen);
11771 return program_arr;
11773 int8_tArray __attribute__((export_name("TS_LDKFallback_PubKeyHash_get_pub_key_hash"))) TS_LDKFallback_PubKeyHash_get_pub_key_hash(uint64_t ptr) {
11774 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11775 assert(obj->tag == LDKFallback_PubKeyHash);
11776 int8_tArray pub_key_hash_arr = init_int8_tArray(20, __LINE__);
11777 memcpy(pub_key_hash_arr->elems, obj->pub_key_hash.data, 20);
11778 return pub_key_hash_arr;
11780 int8_tArray __attribute__((export_name("TS_LDKFallback_ScriptHash_get_script_hash"))) TS_LDKFallback_ScriptHash_get_script_hash(uint64_t ptr) {
11781 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
11782 assert(obj->tag == LDKFallback_ScriptHash);
11783 int8_tArray script_hash_arr = init_int8_tArray(20, __LINE__);
11784 memcpy(script_hash_arr->elems, obj->script_hash.data, 20);
11785 return script_hash_arr;
11787 jstring __attribute__((export_name("TS__ldk_get_compiled_version"))) TS__ldk_get_compiled_version() {
11788 LDKStr ret_str = _ldk_get_compiled_version();
11789 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11794 jstring __attribute__((export_name("TS__ldk_c_bindings_get_compiled_version"))) TS__ldk_c_bindings_get_compiled_version() {
11795 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
11796 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11801 int8_tArray __attribute__((export_name("TS_U128_le_bytes"))) TS_U128_le_bytes(int8_tArray val) {
11803 CHECK(val->arr_len == 16);
11804 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
11805 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
11806 memcpy(ret_arr->elems, U128_le_bytes(val_ref).data, 16);
11810 int8_tArray __attribute__((export_name("TS_U128_new"))) TS_U128_new(int8_tArray le_bytes) {
11811 LDKSixteenBytes le_bytes_ref;
11812 CHECK(le_bytes->arr_len == 16);
11813 memcpy(le_bytes_ref.data, le_bytes->elems, 16); FREE(le_bytes);
11814 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
11815 memcpy(ret_arr->elems, U128_new(le_bytes_ref).le_bytes, 16);
11819 uint64_t __attribute__((export_name("TS_BigEndianScalar_new"))) TS_BigEndianScalar_new(int8_tArray big_endian_bytes) {
11820 LDKThirtyTwoBytes big_endian_bytes_ref;
11821 CHECK(big_endian_bytes->arr_len == 32);
11822 memcpy(big_endian_bytes_ref.data, big_endian_bytes->elems, 32); FREE(big_endian_bytes);
11823 LDKBigEndianScalar* ret_ref = MALLOC(sizeof(LDKBigEndianScalar), "LDKBigEndianScalar");
11824 *ret_ref = BigEndianScalar_new(big_endian_bytes_ref);
11825 return tag_ptr(ret_ref, true);
11828 static inline uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg) {
11829 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11830 *ret_copy = Bech32Error_clone(arg);
11831 uint64_t ret_ref = tag_ptr(ret_copy, true);
11834 int64_t __attribute__((export_name("TS_Bech32Error_clone_ptr"))) TS_Bech32Error_clone_ptr(uint64_t arg) {
11835 LDKBech32Error* arg_conv = (LDKBech32Error*)untag_ptr(arg);
11836 int64_t ret_conv = Bech32Error_clone_ptr(arg_conv);
11840 uint64_t __attribute__((export_name("TS_Bech32Error_clone"))) TS_Bech32Error_clone(uint64_t orig) {
11841 LDKBech32Error* orig_conv = (LDKBech32Error*)untag_ptr(orig);
11842 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11843 *ret_copy = Bech32Error_clone(orig_conv);
11844 uint64_t ret_ref = tag_ptr(ret_copy, true);
11848 void __attribute__((export_name("TS_Bech32Error_free"))) TS_Bech32Error_free(uint64_t o) {
11849 if (!ptr_is_owned(o)) return;
11850 void* o_ptr = untag_ptr(o);
11851 CHECK_ACCESS(o_ptr);
11852 LDKBech32Error o_conv = *(LDKBech32Error*)(o_ptr);
11853 FREE(untag_ptr(o));
11854 Bech32Error_free(o_conv);
11857 void __attribute__((export_name("TS_Transaction_free"))) TS_Transaction_free(int8_tArray _res) {
11858 LDKTransaction _res_ref;
11859 _res_ref.datalen = _res->arr_len;
11860 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
11861 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11862 _res_ref.data_is_owned = true;
11863 Transaction_free(_res_ref);
11866 void __attribute__((export_name("TS_Witness_free"))) TS_Witness_free(int8_tArray _res) {
11867 LDKWitness _res_ref;
11868 _res_ref.datalen = _res->arr_len;
11869 _res_ref.data = MALLOC(_res_ref.datalen, "LDKWitness Bytes");
11870 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11871 _res_ref.data_is_owned = true;
11872 Witness_free(_res_ref);
11875 uint64_t __attribute__((export_name("TS_TxOut_new"))) TS_TxOut_new(int8_tArray script_pubkey, int64_t value) {
11876 LDKCVec_u8Z script_pubkey_ref;
11877 script_pubkey_ref.datalen = script_pubkey->arr_len;
11878 script_pubkey_ref.data = MALLOC(script_pubkey_ref.datalen, "LDKCVec_u8Z Bytes");
11879 memcpy(script_pubkey_ref.data, script_pubkey->elems, script_pubkey_ref.datalen); FREE(script_pubkey);
11880 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11881 *ret_ref = TxOut_new(script_pubkey_ref, value);
11882 return tag_ptr(ret_ref, true);
11885 void __attribute__((export_name("TS_TxOut_free"))) TS_TxOut_free(uint64_t _res) {
11886 if (!ptr_is_owned(_res)) return;
11887 void* _res_ptr = untag_ptr(_res);
11888 CHECK_ACCESS(_res_ptr);
11889 LDKTxOut _res_conv = *(LDKTxOut*)(_res_ptr);
11890 FREE(untag_ptr(_res));
11891 TxOut_free(_res_conv);
11894 static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
11895 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11896 *ret_ref = TxOut_clone(arg);
11897 return tag_ptr(ret_ref, true);
11899 int64_t __attribute__((export_name("TS_TxOut_clone_ptr"))) TS_TxOut_clone_ptr(uint64_t arg) {
11900 LDKTxOut* arg_conv = (LDKTxOut*)untag_ptr(arg);
11901 int64_t ret_conv = TxOut_clone_ptr(arg_conv);
11905 uint64_t __attribute__((export_name("TS_TxOut_clone"))) TS_TxOut_clone(uint64_t orig) {
11906 LDKTxOut* orig_conv = (LDKTxOut*)untag_ptr(orig);
11907 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11908 *ret_ref = TxOut_clone(orig_conv);
11909 return tag_ptr(ret_ref, true);
11912 void __attribute__((export_name("TS_Str_free"))) TS_Str_free(jstring _res) {
11913 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
11917 uint64_t __attribute__((export_name("TS_COption_DurationZ_some"))) TS_COption_DurationZ_some(int64_t o) {
11918 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11919 *ret_copy = COption_DurationZ_some(o);
11920 uint64_t ret_ref = tag_ptr(ret_copy, true);
11924 uint64_t __attribute__((export_name("TS_COption_DurationZ_none"))) TS_COption_DurationZ_none() {
11925 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11926 *ret_copy = COption_DurationZ_none();
11927 uint64_t ret_ref = tag_ptr(ret_copy, true);
11931 void __attribute__((export_name("TS_COption_DurationZ_free"))) TS_COption_DurationZ_free(uint64_t _res) {
11932 if (!ptr_is_owned(_res)) return;
11933 void* _res_ptr = untag_ptr(_res);
11934 CHECK_ACCESS(_res_ptr);
11935 LDKCOption_DurationZ _res_conv = *(LDKCOption_DurationZ*)(_res_ptr);
11936 FREE(untag_ptr(_res));
11937 COption_DurationZ_free(_res_conv);
11940 static inline uint64_t COption_DurationZ_clone_ptr(LDKCOption_DurationZ *NONNULL_PTR arg) {
11941 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11942 *ret_copy = COption_DurationZ_clone(arg);
11943 uint64_t ret_ref = tag_ptr(ret_copy, true);
11946 int64_t __attribute__((export_name("TS_COption_DurationZ_clone_ptr"))) TS_COption_DurationZ_clone_ptr(uint64_t arg) {
11947 LDKCOption_DurationZ* arg_conv = (LDKCOption_DurationZ*)untag_ptr(arg);
11948 int64_t ret_conv = COption_DurationZ_clone_ptr(arg_conv);
11952 uint64_t __attribute__((export_name("TS_COption_DurationZ_clone"))) TS_COption_DurationZ_clone(uint64_t orig) {
11953 LDKCOption_DurationZ* orig_conv = (LDKCOption_DurationZ*)untag_ptr(orig);
11954 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
11955 *ret_copy = COption_DurationZ_clone(orig_conv);
11956 uint64_t ret_ref = tag_ptr(ret_copy, true);
11960 void __attribute__((export_name("TS_CVec_BlindedPathZ_free"))) TS_CVec_BlindedPathZ_free(uint64_tArray _res) {
11961 LDKCVec_BlindedPathZ _res_constr;
11962 _res_constr.datalen = _res->arr_len;
11963 if (_res_constr.datalen > 0)
11964 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBlindedPath), "LDKCVec_BlindedPathZ Elements");
11966 _res_constr.data = NULL;
11967 uint64_t* _res_vals = _res->elems;
11968 for (size_t n = 0; n < _res_constr.datalen; n++) {
11969 uint64_t _res_conv_13 = _res_vals[n];
11970 LDKBlindedPath _res_conv_13_conv;
11971 _res_conv_13_conv.inner = untag_ptr(_res_conv_13);
11972 _res_conv_13_conv.is_owned = ptr_is_owned(_res_conv_13);
11973 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_13_conv);
11974 _res_constr.data[n] = _res_conv_13_conv;
11977 CVec_BlindedPathZ_free(_res_constr);
11980 uint64_t __attribute__((export_name("TS_COption_u64Z_some"))) TS_COption_u64Z_some(int64_t o) {
11981 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
11982 *ret_copy = COption_u64Z_some(o);
11983 uint64_t ret_ref = tag_ptr(ret_copy, true);
11987 uint64_t __attribute__((export_name("TS_COption_u64Z_none"))) TS_COption_u64Z_none() {
11988 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
11989 *ret_copy = COption_u64Z_none();
11990 uint64_t ret_ref = tag_ptr(ret_copy, true);
11994 void __attribute__((export_name("TS_COption_u64Z_free"))) TS_COption_u64Z_free(uint64_t _res) {
11995 if (!ptr_is_owned(_res)) return;
11996 void* _res_ptr = untag_ptr(_res);
11997 CHECK_ACCESS(_res_ptr);
11998 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(_res_ptr);
11999 FREE(untag_ptr(_res));
12000 COption_u64Z_free(_res_conv);
12003 static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
12004 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12005 *ret_copy = COption_u64Z_clone(arg);
12006 uint64_t ret_ref = tag_ptr(ret_copy, true);
12009 int64_t __attribute__((export_name("TS_COption_u64Z_clone_ptr"))) TS_COption_u64Z_clone_ptr(uint64_t arg) {
12010 LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)untag_ptr(arg);
12011 int64_t ret_conv = COption_u64Z_clone_ptr(arg_conv);
12015 uint64_t __attribute__((export_name("TS_COption_u64Z_clone"))) TS_COption_u64Z_clone(uint64_t orig) {
12016 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)untag_ptr(orig);
12017 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12018 *ret_copy = COption_u64Z_clone(orig_conv);
12019 uint64_t ret_ref = tag_ptr(ret_copy, true);
12023 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_ok"))) TS_CResult_NoneAPIErrorZ_ok() {
12024 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12025 *ret_conv = CResult_NoneAPIErrorZ_ok();
12026 return tag_ptr(ret_conv, true);
12029 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_err"))) TS_CResult_NoneAPIErrorZ_err(uint64_t e) {
12030 void* e_ptr = untag_ptr(e);
12031 CHECK_ACCESS(e_ptr);
12032 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
12033 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
12034 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12035 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
12036 return tag_ptr(ret_conv, true);
12039 jboolean __attribute__((export_name("TS_CResult_NoneAPIErrorZ_is_ok"))) TS_CResult_NoneAPIErrorZ_is_ok(uint64_t o) {
12040 LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(o);
12041 jboolean ret_conv = CResult_NoneAPIErrorZ_is_ok(o_conv);
12045 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_free"))) TS_CResult_NoneAPIErrorZ_free(uint64_t _res) {
12046 if (!ptr_is_owned(_res)) return;
12047 void* _res_ptr = untag_ptr(_res);
12048 CHECK_ACCESS(_res_ptr);
12049 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_ptr);
12050 FREE(untag_ptr(_res));
12051 CResult_NoneAPIErrorZ_free(_res_conv);
12054 static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
12055 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12056 *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
12057 return tag_ptr(ret_conv, true);
12059 int64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone_ptr"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint64_t arg) {
12060 LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(arg);
12061 int64_t ret_conv = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
12065 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone"))) TS_CResult_NoneAPIErrorZ_clone(uint64_t orig) {
12066 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(orig);
12067 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
12068 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
12069 return tag_ptr(ret_conv, true);
12072 void __attribute__((export_name("TS_CVec_CResult_NoneAPIErrorZZ_free"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint64_tArray _res) {
12073 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
12074 _res_constr.datalen = _res->arr_len;
12075 if (_res_constr.datalen > 0)
12076 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
12078 _res_constr.data = NULL;
12079 uint64_t* _res_vals = _res->elems;
12080 for (size_t w = 0; w < _res_constr.datalen; w++) {
12081 uint64_t _res_conv_22 = _res_vals[w];
12082 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
12083 CHECK_ACCESS(_res_conv_22_ptr);
12084 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_conv_22_ptr);
12085 FREE(untag_ptr(_res_conv_22));
12086 _res_constr.data[w] = _res_conv_22_conv;
12089 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
12092 void __attribute__((export_name("TS_CVec_APIErrorZ_free"))) TS_CVec_APIErrorZ_free(uint64_tArray _res) {
12093 LDKCVec_APIErrorZ _res_constr;
12094 _res_constr.datalen = _res->arr_len;
12095 if (_res_constr.datalen > 0)
12096 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
12098 _res_constr.data = NULL;
12099 uint64_t* _res_vals = _res->elems;
12100 for (size_t k = 0; k < _res_constr.datalen; k++) {
12101 uint64_t _res_conv_10 = _res_vals[k];
12102 void* _res_conv_10_ptr = untag_ptr(_res_conv_10);
12103 CHECK_ACCESS(_res_conv_10_ptr);
12104 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(_res_conv_10_ptr);
12105 FREE(untag_ptr(_res_conv_10));
12106 _res_constr.data[k] = _res_conv_10_conv;
12109 CVec_APIErrorZ_free(_res_constr);
12112 void __attribute__((export_name("TS_CVec_u8Z_free"))) TS_CVec_u8Z_free(int8_tArray _res) {
12113 LDKCVec_u8Z _res_ref;
12114 _res_ref.datalen = _res->arr_len;
12115 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
12116 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
12117 CVec_u8Z_free(_res_ref);
12120 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_some"))) TS_COption_CVec_u8ZZ_some(int8_tArray o) {
12122 o_ref.datalen = o->arr_len;
12123 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
12124 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
12125 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12126 *ret_copy = COption_CVec_u8ZZ_some(o_ref);
12127 uint64_t ret_ref = tag_ptr(ret_copy, true);
12131 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_none"))) TS_COption_CVec_u8ZZ_none() {
12132 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12133 *ret_copy = COption_CVec_u8ZZ_none();
12134 uint64_t ret_ref = tag_ptr(ret_copy, true);
12138 void __attribute__((export_name("TS_COption_CVec_u8ZZ_free"))) TS_COption_CVec_u8ZZ_free(uint64_t _res) {
12139 if (!ptr_is_owned(_res)) return;
12140 void* _res_ptr = untag_ptr(_res);
12141 CHECK_ACCESS(_res_ptr);
12142 LDKCOption_CVec_u8ZZ _res_conv = *(LDKCOption_CVec_u8ZZ*)(_res_ptr);
12143 FREE(untag_ptr(_res));
12144 COption_CVec_u8ZZ_free(_res_conv);
12147 static inline uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg) {
12148 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12149 *ret_copy = COption_CVec_u8ZZ_clone(arg);
12150 uint64_t ret_ref = tag_ptr(ret_copy, true);
12153 int64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_clone_ptr"))) TS_COption_CVec_u8ZZ_clone_ptr(uint64_t arg) {
12154 LDKCOption_CVec_u8ZZ* arg_conv = (LDKCOption_CVec_u8ZZ*)untag_ptr(arg);
12155 int64_t ret_conv = COption_CVec_u8ZZ_clone_ptr(arg_conv);
12159 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_clone"))) TS_COption_CVec_u8ZZ_clone(uint64_t orig) {
12160 LDKCOption_CVec_u8ZZ* orig_conv = (LDKCOption_CVec_u8ZZ*)untag_ptr(orig);
12161 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
12162 *ret_copy = COption_CVec_u8ZZ_clone(orig_conv);
12163 uint64_t ret_ref = tag_ptr(ret_copy, true);
12167 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(uint64_t o) {
12168 LDKRecipientOnionFields o_conv;
12169 o_conv.inner = untag_ptr(o);
12170 o_conv.is_owned = ptr_is_owned(o);
12171 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12172 o_conv = RecipientOnionFields_clone(&o_conv);
12173 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12174 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_ok(o_conv);
12175 return tag_ptr(ret_conv, true);
12178 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_err"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(uint64_t e) {
12179 void* e_ptr = untag_ptr(e);
12180 CHECK_ACCESS(e_ptr);
12181 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12182 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12183 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12184 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_err(e_conv);
12185 return tag_ptr(ret_conv, true);
12188 jboolean __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(uint64_t o) {
12189 LDKCResult_RecipientOnionFieldsDecodeErrorZ* o_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(o);
12190 jboolean ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o_conv);
12194 void __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_free"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(uint64_t _res) {
12195 if (!ptr_is_owned(_res)) return;
12196 void* _res_ptr = untag_ptr(_res);
12197 CHECK_ACCESS(_res_ptr);
12198 LDKCResult_RecipientOnionFieldsDecodeErrorZ _res_conv = *(LDKCResult_RecipientOnionFieldsDecodeErrorZ*)(_res_ptr);
12199 FREE(untag_ptr(_res));
12200 CResult_RecipientOnionFieldsDecodeErrorZ_free(_res_conv);
12203 static inline uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg) {
12204 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12205 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone(arg);
12206 return tag_ptr(ret_conv, true);
12208 int64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(uint64_t arg) {
12209 LDKCResult_RecipientOnionFieldsDecodeErrorZ* arg_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(arg);
12210 int64_t ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg_conv);
12214 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(uint64_t orig) {
12215 LDKCResult_RecipientOnionFieldsDecodeErrorZ* orig_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(orig);
12216 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
12217 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig_conv);
12218 return tag_ptr(ret_conv, true);
12221 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_some"))) TS_COption_HTLCClaimZ_some(uint32_t o) {
12222 LDKHTLCClaim o_conv = LDKHTLCClaim_from_js(o);
12223 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
12224 *ret_copy = COption_HTLCClaimZ_some(o_conv);
12225 uint64_t ret_ref = tag_ptr(ret_copy, true);
12229 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_none"))) TS_COption_HTLCClaimZ_none() {
12230 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
12231 *ret_copy = COption_HTLCClaimZ_none();
12232 uint64_t ret_ref = tag_ptr(ret_copy, true);
12236 void __attribute__((export_name("TS_COption_HTLCClaimZ_free"))) TS_COption_HTLCClaimZ_free(uint64_t _res) {
12237 if (!ptr_is_owned(_res)) return;
12238 void* _res_ptr = untag_ptr(_res);
12239 CHECK_ACCESS(_res_ptr);
12240 LDKCOption_HTLCClaimZ _res_conv = *(LDKCOption_HTLCClaimZ*)(_res_ptr);
12241 FREE(untag_ptr(_res));
12242 COption_HTLCClaimZ_free(_res_conv);
12245 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_ok"))) TS_CResult_NoneNoneZ_ok() {
12246 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12247 *ret_conv = CResult_NoneNoneZ_ok();
12248 return tag_ptr(ret_conv, true);
12251 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_err"))) TS_CResult_NoneNoneZ_err() {
12252 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12253 *ret_conv = CResult_NoneNoneZ_err();
12254 return tag_ptr(ret_conv, true);
12257 jboolean __attribute__((export_name("TS_CResult_NoneNoneZ_is_ok"))) TS_CResult_NoneNoneZ_is_ok(uint64_t o) {
12258 LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)untag_ptr(o);
12259 jboolean ret_conv = CResult_NoneNoneZ_is_ok(o_conv);
12263 void __attribute__((export_name("TS_CResult_NoneNoneZ_free"))) TS_CResult_NoneNoneZ_free(uint64_t _res) {
12264 if (!ptr_is_owned(_res)) return;
12265 void* _res_ptr = untag_ptr(_res);
12266 CHECK_ACCESS(_res_ptr);
12267 LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(_res_ptr);
12268 FREE(untag_ptr(_res));
12269 CResult_NoneNoneZ_free(_res_conv);
12272 static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
12273 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12274 *ret_conv = CResult_NoneNoneZ_clone(arg);
12275 return tag_ptr(ret_conv, true);
12277 int64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone_ptr"))) TS_CResult_NoneNoneZ_clone_ptr(uint64_t arg) {
12278 LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)untag_ptr(arg);
12279 int64_t ret_conv = CResult_NoneNoneZ_clone_ptr(arg_conv);
12283 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone"))) TS_CResult_NoneNoneZ_clone(uint64_t orig) {
12284 LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)untag_ptr(orig);
12285 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
12286 *ret_conv = CResult_NoneNoneZ_clone(orig_conv);
12287 return tag_ptr(ret_conv, true);
12290 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(uint64_t o) {
12291 LDKCounterpartyCommitmentSecrets o_conv;
12292 o_conv.inner = untag_ptr(o);
12293 o_conv.is_owned = ptr_is_owned(o);
12294 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12295 o_conv = CounterpartyCommitmentSecrets_clone(&o_conv);
12296 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12297 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o_conv);
12298 return tag_ptr(ret_conv, true);
12301 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(uint64_t e) {
12302 void* e_ptr = untag_ptr(e);
12303 CHECK_ACCESS(e_ptr);
12304 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12305 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12306 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12307 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e_conv);
12308 return tag_ptr(ret_conv, true);
12311 jboolean __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(uint64_t o) {
12312 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* o_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(o);
12313 jboolean ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o_conv);
12317 void __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(uint64_t _res) {
12318 if (!ptr_is_owned(_res)) return;
12319 void* _res_ptr = untag_ptr(_res);
12320 CHECK_ACCESS(_res_ptr);
12321 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(_res_ptr);
12322 FREE(untag_ptr(_res));
12323 CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res_conv);
12326 static inline uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg) {
12327 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12328 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(arg);
12329 return tag_ptr(ret_conv, true);
12331 int64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(uint64_t arg) {
12332 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(arg);
12333 int64_t ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg_conv);
12337 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(uint64_t orig) {
12338 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(orig);
12339 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
12340 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig_conv);
12341 return tag_ptr(ret_conv, true);
12344 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_ok(uint64_t o) {
12345 LDKTxCreationKeys o_conv;
12346 o_conv.inner = untag_ptr(o);
12347 o_conv.is_owned = ptr_is_owned(o);
12348 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12349 o_conv = TxCreationKeys_clone(&o_conv);
12350 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12351 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
12352 return tag_ptr(ret_conv, true);
12355 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_err(uint64_t e) {
12356 void* e_ptr = untag_ptr(e);
12357 CHECK_ACCESS(e_ptr);
12358 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12359 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12360 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12361 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
12362 return tag_ptr(ret_conv, true);
12365 jboolean __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_is_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint64_t o) {
12366 LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(o);
12367 jboolean ret_conv = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
12371 void __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_free"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint64_t _res) {
12372 if (!ptr_is_owned(_res)) return;
12373 void* _res_ptr = untag_ptr(_res);
12374 CHECK_ACCESS(_res_ptr);
12375 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(_res_ptr);
12376 FREE(untag_ptr(_res));
12377 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
12380 static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
12381 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12382 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
12383 return tag_ptr(ret_conv, true);
12385 int64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
12386 LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(arg);
12387 int64_t ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
12391 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint64_t orig) {
12392 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(orig);
12393 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
12394 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
12395 return tag_ptr(ret_conv, true);
12398 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(uint64_t o) {
12399 LDKChannelPublicKeys o_conv;
12400 o_conv.inner = untag_ptr(o);
12401 o_conv.is_owned = ptr_is_owned(o);
12402 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12403 o_conv = ChannelPublicKeys_clone(&o_conv);
12404 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12405 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
12406 return tag_ptr(ret_conv, true);
12409 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_err(uint64_t e) {
12410 void* e_ptr = untag_ptr(e);
12411 CHECK_ACCESS(e_ptr);
12412 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12413 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12414 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12415 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
12416 return tag_ptr(ret_conv, true);
12419 jboolean __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint64_t o) {
12420 LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(o);
12421 jboolean ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
12425 void __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_free"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint64_t _res) {
12426 if (!ptr_is_owned(_res)) return;
12427 void* _res_ptr = untag_ptr(_res);
12428 CHECK_ACCESS(_res_ptr);
12429 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(_res_ptr);
12430 FREE(untag_ptr(_res));
12431 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
12434 static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
12435 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12436 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
12437 return tag_ptr(ret_conv, true);
12439 int64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
12440 LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(arg);
12441 int64_t ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
12445 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint64_t orig) {
12446 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(orig);
12447 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
12448 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
12449 return tag_ptr(ret_conv, true);
12452 uint64_t __attribute__((export_name("TS_COption_u32Z_some"))) TS_COption_u32Z_some(int32_t o) {
12453 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12454 *ret_copy = COption_u32Z_some(o);
12455 uint64_t ret_ref = tag_ptr(ret_copy, true);
12459 uint64_t __attribute__((export_name("TS_COption_u32Z_none"))) TS_COption_u32Z_none() {
12460 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12461 *ret_copy = COption_u32Z_none();
12462 uint64_t ret_ref = tag_ptr(ret_copy, true);
12466 void __attribute__((export_name("TS_COption_u32Z_free"))) TS_COption_u32Z_free(uint64_t _res) {
12467 if (!ptr_is_owned(_res)) return;
12468 void* _res_ptr = untag_ptr(_res);
12469 CHECK_ACCESS(_res_ptr);
12470 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(_res_ptr);
12471 FREE(untag_ptr(_res));
12472 COption_u32Z_free(_res_conv);
12475 static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
12476 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12477 *ret_copy = COption_u32Z_clone(arg);
12478 uint64_t ret_ref = tag_ptr(ret_copy, true);
12481 int64_t __attribute__((export_name("TS_COption_u32Z_clone_ptr"))) TS_COption_u32Z_clone_ptr(uint64_t arg) {
12482 LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)untag_ptr(arg);
12483 int64_t ret_conv = COption_u32Z_clone_ptr(arg_conv);
12487 uint64_t __attribute__((export_name("TS_COption_u32Z_clone"))) TS_COption_u32Z_clone(uint64_t orig) {
12488 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)untag_ptr(orig);
12489 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
12490 *ret_copy = COption_u32Z_clone(orig_conv);
12491 uint64_t ret_ref = tag_ptr(ret_copy, true);
12495 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(uint64_t o) {
12496 LDKHTLCOutputInCommitment o_conv;
12497 o_conv.inner = untag_ptr(o);
12498 o_conv.is_owned = ptr_is_owned(o);
12499 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12500 o_conv = HTLCOutputInCommitment_clone(&o_conv);
12501 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12502 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
12503 return tag_ptr(ret_conv, true);
12506 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(uint64_t e) {
12507 void* e_ptr = untag_ptr(e);
12508 CHECK_ACCESS(e_ptr);
12509 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12510 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12511 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12512 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
12513 return tag_ptr(ret_conv, true);
12516 jboolean __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint64_t o) {
12517 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(o);
12518 jboolean ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
12522 void __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint64_t _res) {
12523 if (!ptr_is_owned(_res)) return;
12524 void* _res_ptr = untag_ptr(_res);
12525 CHECK_ACCESS(_res_ptr);
12526 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(_res_ptr);
12527 FREE(untag_ptr(_res));
12528 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
12531 static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
12532 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12533 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
12534 return tag_ptr(ret_conv, true);
12536 int64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint64_t arg) {
12537 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(arg);
12538 int64_t ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
12542 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint64_t orig) {
12543 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(orig);
12544 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
12545 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
12546 return tag_ptr(ret_conv, true);
12549 uint32_t __attribute__((export_name("TS_COption_NoneZ_some"))) TS_COption_NoneZ_some() {
12550 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_some());
12554 uint32_t __attribute__((export_name("TS_COption_NoneZ_none"))) TS_COption_NoneZ_none() {
12555 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_none());
12559 void __attribute__((export_name("TS_COption_NoneZ_free"))) TS_COption_NoneZ_free(uint32_t _res) {
12560 LDKCOption_NoneZ _res_conv = LDKCOption_NoneZ_from_js(_res);
12561 COption_NoneZ_free(_res_conv);
12564 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
12565 LDKCounterpartyChannelTransactionParameters o_conv;
12566 o_conv.inner = untag_ptr(o);
12567 o_conv.is_owned = ptr_is_owned(o);
12568 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12569 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
12570 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12571 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
12572 return tag_ptr(ret_conv, true);
12575 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
12576 void* e_ptr = untag_ptr(e);
12577 CHECK_ACCESS(e_ptr);
12578 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12579 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12580 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12581 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
12582 return tag_ptr(ret_conv, true);
12585 jboolean __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
12586 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
12587 jboolean ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
12591 void __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
12592 if (!ptr_is_owned(_res)) return;
12593 void* _res_ptr = untag_ptr(_res);
12594 CHECK_ACCESS(_res_ptr);
12595 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
12596 FREE(untag_ptr(_res));
12597 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
12600 static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
12601 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12602 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
12603 return tag_ptr(ret_conv, true);
12605 int64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
12606 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
12607 int64_t ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
12611 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
12612 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
12613 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
12614 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
12615 return tag_ptr(ret_conv, true);
12618 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
12619 LDKChannelTransactionParameters o_conv;
12620 o_conv.inner = untag_ptr(o);
12621 o_conv.is_owned = ptr_is_owned(o);
12622 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12623 o_conv = ChannelTransactionParameters_clone(&o_conv);
12624 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12625 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
12626 return tag_ptr(ret_conv, true);
12629 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
12630 void* e_ptr = untag_ptr(e);
12631 CHECK_ACCESS(e_ptr);
12632 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12633 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12634 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12635 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
12636 return tag_ptr(ret_conv, true);
12639 jboolean __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
12640 LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
12641 jboolean ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
12645 void __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
12646 if (!ptr_is_owned(_res)) return;
12647 void* _res_ptr = untag_ptr(_res);
12648 CHECK_ACCESS(_res_ptr);
12649 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
12650 FREE(untag_ptr(_res));
12651 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
12654 static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
12655 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12656 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
12657 return tag_ptr(ret_conv, true);
12659 int64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
12660 LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
12661 int64_t ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
12665 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
12666 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
12667 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
12668 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
12669 return tag_ptr(ret_conv, true);
12672 void __attribute__((export_name("TS_CVec_SignatureZ_free"))) TS_CVec_SignatureZ_free(ptrArray _res) {
12673 LDKCVec_SignatureZ _res_constr;
12674 _res_constr.datalen = _res->arr_len;
12675 if (_res_constr.datalen > 0)
12676 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12678 _res_constr.data = NULL;
12679 int8_tArray* _res_vals = (void*) _res->elems;
12680 for (size_t m = 0; m < _res_constr.datalen; m++) {
12681 int8_tArray _res_conv_12 = _res_vals[m];
12682 LDKSignature _res_conv_12_ref;
12683 CHECK(_res_conv_12->arr_len == 64);
12684 memcpy(_res_conv_12_ref.compact_form, _res_conv_12->elems, 64); FREE(_res_conv_12);
12685 _res_constr.data[m] = _res_conv_12_ref;
12688 CVec_SignatureZ_free(_res_constr);
12691 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12692 LDKHolderCommitmentTransaction o_conv;
12693 o_conv.inner = untag_ptr(o);
12694 o_conv.is_owned = ptr_is_owned(o);
12695 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12696 o_conv = HolderCommitmentTransaction_clone(&o_conv);
12697 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12698 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
12699 return tag_ptr(ret_conv, true);
12702 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12703 void* e_ptr = untag_ptr(e);
12704 CHECK_ACCESS(e_ptr);
12705 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12706 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12707 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12708 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
12709 return tag_ptr(ret_conv, true);
12712 jboolean __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12713 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12714 jboolean ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12718 void __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12719 if (!ptr_is_owned(_res)) return;
12720 void* _res_ptr = untag_ptr(_res);
12721 CHECK_ACCESS(_res_ptr);
12722 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12723 FREE(untag_ptr(_res));
12724 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
12727 static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12728 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12729 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
12730 return tag_ptr(ret_conv, true);
12732 int64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12733 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12734 int64_t ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12738 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12739 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12740 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12741 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12742 return tag_ptr(ret_conv, true);
12745 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12746 LDKBuiltCommitmentTransaction o_conv;
12747 o_conv.inner = untag_ptr(o);
12748 o_conv.is_owned = ptr_is_owned(o);
12749 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12750 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
12751 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12752 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
12753 return tag_ptr(ret_conv, true);
12756 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12757 void* e_ptr = untag_ptr(e);
12758 CHECK_ACCESS(e_ptr);
12759 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12760 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12761 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12762 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
12763 return tag_ptr(ret_conv, true);
12766 jboolean __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12767 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12768 jboolean ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12772 void __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12773 if (!ptr_is_owned(_res)) return;
12774 void* _res_ptr = untag_ptr(_res);
12775 CHECK_ACCESS(_res_ptr);
12776 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12777 FREE(untag_ptr(_res));
12778 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
12781 static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12782 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12783 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
12784 return tag_ptr(ret_conv, true);
12786 int64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12787 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12788 int64_t ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12792 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12793 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12794 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12795 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12796 return tag_ptr(ret_conv, true);
12799 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_ok(uint64_t o) {
12800 LDKTrustedClosingTransaction o_conv;
12801 o_conv.inner = untag_ptr(o);
12802 o_conv.is_owned = ptr_is_owned(o);
12803 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12804 // WARNING: we need a move here but no clone is available for LDKTrustedClosingTransaction
12806 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12807 *ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
12808 return tag_ptr(ret_conv, true);
12811 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_err"))) TS_CResult_TrustedClosingTransactionNoneZ_err() {
12812 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12813 *ret_conv = CResult_TrustedClosingTransactionNoneZ_err();
12814 return tag_ptr(ret_conv, true);
12817 jboolean __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_is_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint64_t o) {
12818 LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(o);
12819 jboolean ret_conv = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
12823 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_free"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint64_t _res) {
12824 if (!ptr_is_owned(_res)) return;
12825 void* _res_ptr = untag_ptr(_res);
12826 CHECK_ACCESS(_res_ptr);
12827 LDKCResult_TrustedClosingTransactionNoneZ _res_conv = *(LDKCResult_TrustedClosingTransactionNoneZ*)(_res_ptr);
12828 FREE(untag_ptr(_res));
12829 CResult_TrustedClosingTransactionNoneZ_free(_res_conv);
12832 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
12833 LDKCommitmentTransaction o_conv;
12834 o_conv.inner = untag_ptr(o);
12835 o_conv.is_owned = ptr_is_owned(o);
12836 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12837 o_conv = CommitmentTransaction_clone(&o_conv);
12838 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12839 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
12840 return tag_ptr(ret_conv, true);
12843 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_err(uint64_t e) {
12844 void* e_ptr = untag_ptr(e);
12845 CHECK_ACCESS(e_ptr);
12846 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12847 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12848 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12849 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
12850 return tag_ptr(ret_conv, true);
12853 jboolean __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
12854 LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(o);
12855 jboolean ret_conv = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12859 void __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_free"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
12860 if (!ptr_is_owned(_res)) return;
12861 void* _res_ptr = untag_ptr(_res);
12862 CHECK_ACCESS(_res_ptr);
12863 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(_res_ptr);
12864 FREE(untag_ptr(_res));
12865 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
12868 static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12869 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12870 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
12871 return tag_ptr(ret_conv, true);
12873 int64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
12874 LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
12875 int64_t ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12879 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
12880 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
12881 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12882 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
12883 return tag_ptr(ret_conv, true);
12886 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_ok(uint64_t o) {
12887 LDKTrustedCommitmentTransaction o_conv;
12888 o_conv.inner = untag_ptr(o);
12889 o_conv.is_owned = ptr_is_owned(o);
12890 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12891 // WARNING: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
12893 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12894 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
12895 return tag_ptr(ret_conv, true);
12898 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
12899 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12900 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
12901 return tag_ptr(ret_conv, true);
12904 jboolean __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint64_t o) {
12905 LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(o);
12906 jboolean ret_conv = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
12910 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_free"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint64_t _res) {
12911 if (!ptr_is_owned(_res)) return;
12912 void* _res_ptr = untag_ptr(_res);
12913 CHECK_ACCESS(_res_ptr);
12914 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(_res_ptr);
12915 FREE(untag_ptr(_res));
12916 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
12919 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_ok"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
12920 LDKCVec_SignatureZ o_constr;
12921 o_constr.datalen = o->arr_len;
12922 if (o_constr.datalen > 0)
12923 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12925 o_constr.data = NULL;
12926 int8_tArray* o_vals = (void*) o->elems;
12927 for (size_t m = 0; m < o_constr.datalen; m++) {
12928 int8_tArray o_conv_12 = o_vals[m];
12929 LDKSignature o_conv_12_ref;
12930 CHECK(o_conv_12->arr_len == 64);
12931 memcpy(o_conv_12_ref.compact_form, o_conv_12->elems, 64); FREE(o_conv_12);
12932 o_constr.data[m] = o_conv_12_ref;
12935 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12936 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
12937 return tag_ptr(ret_conv, true);
12940 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_err"))) TS_CResult_CVec_SignatureZNoneZ_err() {
12941 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12942 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
12943 return tag_ptr(ret_conv, true);
12946 jboolean __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_is_ok"))) TS_CResult_CVec_SignatureZNoneZ_is_ok(uint64_t o) {
12947 LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(o);
12948 jboolean ret_conv = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
12952 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_free"))) TS_CResult_CVec_SignatureZNoneZ_free(uint64_t _res) {
12953 if (!ptr_is_owned(_res)) return;
12954 void* _res_ptr = untag_ptr(_res);
12955 CHECK_ACCESS(_res_ptr);
12956 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(_res_ptr);
12957 FREE(untag_ptr(_res));
12958 CResult_CVec_SignatureZNoneZ_free(_res_conv);
12961 static inline uint64_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
12962 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12963 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
12964 return tag_ptr(ret_conv, true);
12966 int64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone_ptr"))) TS_CResult_CVec_SignatureZNoneZ_clone_ptr(uint64_t arg) {
12967 LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(arg);
12968 int64_t ret_conv = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
12972 uint64_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint64_t orig) {
12973 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)untag_ptr(orig);
12974 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12975 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
12976 return tag_ptr(ret_conv, true);
12979 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_ok(uint64_t o) {
12980 LDKShutdownScript o_conv;
12981 o_conv.inner = untag_ptr(o);
12982 o_conv.is_owned = ptr_is_owned(o);
12983 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12984 o_conv = ShutdownScript_clone(&o_conv);
12985 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12986 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
12987 return tag_ptr(ret_conv, true);
12990 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_err(uint64_t e) {
12991 void* e_ptr = untag_ptr(e);
12992 CHECK_ACCESS(e_ptr);
12993 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
12994 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
12995 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12996 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
12997 return tag_ptr(ret_conv, true);
13000 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_is_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint64_t o) {
13001 LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(o);
13002 jboolean ret_conv = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
13006 void __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_free"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint64_t _res) {
13007 if (!ptr_is_owned(_res)) return;
13008 void* _res_ptr = untag_ptr(_res);
13009 CHECK_ACCESS(_res_ptr);
13010 LDKCResult_ShutdownScriptDecodeErrorZ _res_conv = *(LDKCResult_ShutdownScriptDecodeErrorZ*)(_res_ptr);
13011 FREE(untag_ptr(_res));
13012 CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
13015 static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
13016 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
13017 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
13018 return tag_ptr(ret_conv, true);
13020 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint64_t arg) {
13021 LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(arg);
13022 int64_t ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
13026 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint64_t orig) {
13027 LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(orig);
13028 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
13029 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(orig_conv);
13030 return tag_ptr(ret_conv, true);
13033 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(uint64_t o) {
13034 LDKShutdownScript o_conv;
13035 o_conv.inner = untag_ptr(o);
13036 o_conv.is_owned = ptr_is_owned(o);
13037 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13038 o_conv = ShutdownScript_clone(&o_conv);
13039 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13040 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
13041 return tag_ptr(ret_conv, true);
13044 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(uint64_t e) {
13045 LDKInvalidShutdownScript e_conv;
13046 e_conv.inner = untag_ptr(e);
13047 e_conv.is_owned = ptr_is_owned(e);
13048 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13049 e_conv = InvalidShutdownScript_clone(&e_conv);
13050 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13051 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
13052 return tag_ptr(ret_conv, true);
13055 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint64_t o) {
13056 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(o);
13057 jboolean ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
13061 void __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint64_t _res) {
13062 if (!ptr_is_owned(_res)) return;
13063 void* _res_ptr = untag_ptr(_res);
13064 CHECK_ACCESS(_res_ptr);
13065 LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res_conv = *(LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(_res_ptr);
13066 FREE(untag_ptr(_res));
13067 CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
13070 static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
13071 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13072 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
13073 return tag_ptr(ret_conv, true);
13075 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint64_t arg) {
13076 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(arg);
13077 int64_t ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
13081 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint64_t orig) {
13082 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(orig);
13083 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
13084 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig_conv);
13085 return tag_ptr(ret_conv, true);
13088 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_ok(uint64_t o) {
13089 LDKBlindedPayInfo o_conv;
13090 o_conv.inner = untag_ptr(o);
13091 o_conv.is_owned = ptr_is_owned(o);
13092 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13093 o_conv = BlindedPayInfo_clone(&o_conv);
13094 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13095 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_ok(o_conv);
13096 return tag_ptr(ret_conv, true);
13099 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_err"))) TS_CResult_BlindedPayInfoDecodeErrorZ_err(uint64_t e) {
13100 void* e_ptr = untag_ptr(e);
13101 CHECK_ACCESS(e_ptr);
13102 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13103 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13104 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13105 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_err(e_conv);
13106 return tag_ptr(ret_conv, true);
13109 jboolean __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(uint64_t o) {
13110 LDKCResult_BlindedPayInfoDecodeErrorZ* o_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(o);
13111 jboolean ret_conv = CResult_BlindedPayInfoDecodeErrorZ_is_ok(o_conv);
13115 void __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_free"))) TS_CResult_BlindedPayInfoDecodeErrorZ_free(uint64_t _res) {
13116 if (!ptr_is_owned(_res)) return;
13117 void* _res_ptr = untag_ptr(_res);
13118 CHECK_ACCESS(_res_ptr);
13119 LDKCResult_BlindedPayInfoDecodeErrorZ _res_conv = *(LDKCResult_BlindedPayInfoDecodeErrorZ*)(_res_ptr);
13120 FREE(untag_ptr(_res));
13121 CResult_BlindedPayInfoDecodeErrorZ_free(_res_conv);
13124 static inline uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg) {
13125 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13126 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone(arg);
13127 return tag_ptr(ret_conv, true);
13129 int64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
13130 LDKCResult_BlindedPayInfoDecodeErrorZ* arg_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(arg);
13131 int64_t ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg_conv);
13135 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_clone"))) TS_CResult_BlindedPayInfoDecodeErrorZ_clone(uint64_t orig) {
13136 LDKCResult_BlindedPayInfoDecodeErrorZ* orig_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(orig);
13137 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
13138 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone(orig_conv);
13139 return tag_ptr(ret_conv, true);
13142 void __attribute__((export_name("TS_CVec_ChannelDetailsZ_free"))) TS_CVec_ChannelDetailsZ_free(uint64_tArray _res) {
13143 LDKCVec_ChannelDetailsZ _res_constr;
13144 _res_constr.datalen = _res->arr_len;
13145 if (_res_constr.datalen > 0)
13146 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
13148 _res_constr.data = NULL;
13149 uint64_t* _res_vals = _res->elems;
13150 for (size_t q = 0; q < _res_constr.datalen; q++) {
13151 uint64_t _res_conv_16 = _res_vals[q];
13152 LDKChannelDetails _res_conv_16_conv;
13153 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
13154 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
13155 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
13156 _res_constr.data[q] = _res_conv_16_conv;
13159 CVec_ChannelDetailsZ_free(_res_constr);
13162 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_ok"))) TS_CResult_RouteLightningErrorZ_ok(uint64_t o) {
13164 o_conv.inner = untag_ptr(o);
13165 o_conv.is_owned = ptr_is_owned(o);
13166 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13167 o_conv = Route_clone(&o_conv);
13168 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13169 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
13170 return tag_ptr(ret_conv, true);
13173 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_err"))) TS_CResult_RouteLightningErrorZ_err(uint64_t e) {
13174 LDKLightningError e_conv;
13175 e_conv.inner = untag_ptr(e);
13176 e_conv.is_owned = ptr_is_owned(e);
13177 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13178 e_conv = LightningError_clone(&e_conv);
13179 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13180 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
13181 return tag_ptr(ret_conv, true);
13184 jboolean __attribute__((export_name("TS_CResult_RouteLightningErrorZ_is_ok"))) TS_CResult_RouteLightningErrorZ_is_ok(uint64_t o) {
13185 LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(o);
13186 jboolean ret_conv = CResult_RouteLightningErrorZ_is_ok(o_conv);
13190 void __attribute__((export_name("TS_CResult_RouteLightningErrorZ_free"))) TS_CResult_RouteLightningErrorZ_free(uint64_t _res) {
13191 if (!ptr_is_owned(_res)) return;
13192 void* _res_ptr = untag_ptr(_res);
13193 CHECK_ACCESS(_res_ptr);
13194 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
13195 FREE(untag_ptr(_res));
13196 CResult_RouteLightningErrorZ_free(_res_conv);
13199 static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
13200 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13201 *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
13202 return tag_ptr(ret_conv, true);
13204 int64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone_ptr"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint64_t arg) {
13205 LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(arg);
13206 int64_t ret_conv = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
13210 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone"))) TS_CResult_RouteLightningErrorZ_clone(uint64_t orig) {
13211 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(orig);
13212 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
13213 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
13214 return tag_ptr(ret_conv, true);
13217 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_ok(uint64_t o) {
13218 LDKInFlightHtlcs o_conv;
13219 o_conv.inner = untag_ptr(o);
13220 o_conv.is_owned = ptr_is_owned(o);
13221 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13222 o_conv = InFlightHtlcs_clone(&o_conv);
13223 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13224 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_ok(o_conv);
13225 return tag_ptr(ret_conv, true);
13228 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_err(uint64_t e) {
13229 void* e_ptr = untag_ptr(e);
13230 CHECK_ACCESS(e_ptr);
13231 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13232 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13233 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13234 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_err(e_conv);
13235 return tag_ptr(ret_conv, true);
13238 jboolean __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(uint64_t o) {
13239 LDKCResult_InFlightHtlcsDecodeErrorZ* o_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(o);
13240 jboolean ret_conv = CResult_InFlightHtlcsDecodeErrorZ_is_ok(o_conv);
13244 void __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_free"))) TS_CResult_InFlightHtlcsDecodeErrorZ_free(uint64_t _res) {
13245 if (!ptr_is_owned(_res)) return;
13246 void* _res_ptr = untag_ptr(_res);
13247 CHECK_ACCESS(_res_ptr);
13248 LDKCResult_InFlightHtlcsDecodeErrorZ _res_conv = *(LDKCResult_InFlightHtlcsDecodeErrorZ*)(_res_ptr);
13249 FREE(untag_ptr(_res));
13250 CResult_InFlightHtlcsDecodeErrorZ_free(_res_conv);
13253 static inline uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg) {
13254 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13255 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(arg);
13256 return tag_ptr(ret_conv, true);
13258 int64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(uint64_t arg) {
13259 LDKCResult_InFlightHtlcsDecodeErrorZ* arg_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(arg);
13260 int64_t ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg_conv);
13264 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone(uint64_t orig) {
13265 LDKCResult_InFlightHtlcsDecodeErrorZ* orig_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(orig);
13266 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
13267 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(orig_conv);
13268 return tag_ptr(ret_conv, true);
13271 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_ok"))) TS_CResult_RouteHopDecodeErrorZ_ok(uint64_t o) {
13272 LDKRouteHop o_conv;
13273 o_conv.inner = untag_ptr(o);
13274 o_conv.is_owned = ptr_is_owned(o);
13275 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13276 o_conv = RouteHop_clone(&o_conv);
13277 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13278 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
13279 return tag_ptr(ret_conv, true);
13282 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_err"))) TS_CResult_RouteHopDecodeErrorZ_err(uint64_t e) {
13283 void* e_ptr = untag_ptr(e);
13284 CHECK_ACCESS(e_ptr);
13285 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13286 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13287 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13288 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
13289 return tag_ptr(ret_conv, true);
13292 jboolean __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint64_t o) {
13293 LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(o);
13294 jboolean ret_conv = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
13298 void __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_free"))) TS_CResult_RouteHopDecodeErrorZ_free(uint64_t _res) {
13299 if (!ptr_is_owned(_res)) return;
13300 void* _res_ptr = untag_ptr(_res);
13301 CHECK_ACCESS(_res_ptr);
13302 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(_res_ptr);
13303 FREE(untag_ptr(_res));
13304 CResult_RouteHopDecodeErrorZ_free(_res_conv);
13307 static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
13308 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13309 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
13310 return tag_ptr(ret_conv, true);
13312 int64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint64_t arg) {
13313 LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(arg);
13314 int64_t ret_conv = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
13318 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint64_t orig) {
13319 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(orig);
13320 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
13321 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
13322 return tag_ptr(ret_conv, true);
13325 void __attribute__((export_name("TS_CVec_BlindedHopZ_free"))) TS_CVec_BlindedHopZ_free(uint64_tArray _res) {
13326 LDKCVec_BlindedHopZ _res_constr;
13327 _res_constr.datalen = _res->arr_len;
13328 if (_res_constr.datalen > 0)
13329 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
13331 _res_constr.data = NULL;
13332 uint64_t* _res_vals = _res->elems;
13333 for (size_t m = 0; m < _res_constr.datalen; m++) {
13334 uint64_t _res_conv_12 = _res_vals[m];
13335 LDKBlindedHop _res_conv_12_conv;
13336 _res_conv_12_conv.inner = untag_ptr(_res_conv_12);
13337 _res_conv_12_conv.is_owned = ptr_is_owned(_res_conv_12);
13338 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv);
13339 _res_constr.data[m] = _res_conv_12_conv;
13342 CVec_BlindedHopZ_free(_res_constr);
13345 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_ok"))) TS_CResult_BlindedTailDecodeErrorZ_ok(uint64_t o) {
13346 LDKBlindedTail o_conv;
13347 o_conv.inner = untag_ptr(o);
13348 o_conv.is_owned = ptr_is_owned(o);
13349 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13350 o_conv = BlindedTail_clone(&o_conv);
13351 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13352 *ret_conv = CResult_BlindedTailDecodeErrorZ_ok(o_conv);
13353 return tag_ptr(ret_conv, true);
13356 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_err"))) TS_CResult_BlindedTailDecodeErrorZ_err(uint64_t e) {
13357 void* e_ptr = untag_ptr(e);
13358 CHECK_ACCESS(e_ptr);
13359 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13360 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13361 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13362 *ret_conv = CResult_BlindedTailDecodeErrorZ_err(e_conv);
13363 return tag_ptr(ret_conv, true);
13366 jboolean __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_is_ok"))) TS_CResult_BlindedTailDecodeErrorZ_is_ok(uint64_t o) {
13367 LDKCResult_BlindedTailDecodeErrorZ* o_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(o);
13368 jboolean ret_conv = CResult_BlindedTailDecodeErrorZ_is_ok(o_conv);
13372 void __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_free"))) TS_CResult_BlindedTailDecodeErrorZ_free(uint64_t _res) {
13373 if (!ptr_is_owned(_res)) return;
13374 void* _res_ptr = untag_ptr(_res);
13375 CHECK_ACCESS(_res_ptr);
13376 LDKCResult_BlindedTailDecodeErrorZ _res_conv = *(LDKCResult_BlindedTailDecodeErrorZ*)(_res_ptr);
13377 FREE(untag_ptr(_res));
13378 CResult_BlindedTailDecodeErrorZ_free(_res_conv);
13381 static inline uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg) {
13382 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13383 *ret_conv = CResult_BlindedTailDecodeErrorZ_clone(arg);
13384 return tag_ptr(ret_conv, true);
13386 int64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(uint64_t arg) {
13387 LDKCResult_BlindedTailDecodeErrorZ* arg_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(arg);
13388 int64_t ret_conv = CResult_BlindedTailDecodeErrorZ_clone_ptr(arg_conv);
13392 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_clone"))) TS_CResult_BlindedTailDecodeErrorZ_clone(uint64_t orig) {
13393 LDKCResult_BlindedTailDecodeErrorZ* orig_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(orig);
13394 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
13395 *ret_conv = CResult_BlindedTailDecodeErrorZ_clone(orig_conv);
13396 return tag_ptr(ret_conv, true);
13399 void __attribute__((export_name("TS_CVec_RouteHopZ_free"))) TS_CVec_RouteHopZ_free(uint64_tArray _res) {
13400 LDKCVec_RouteHopZ _res_constr;
13401 _res_constr.datalen = _res->arr_len;
13402 if (_res_constr.datalen > 0)
13403 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
13405 _res_constr.data = NULL;
13406 uint64_t* _res_vals = _res->elems;
13407 for (size_t k = 0; k < _res_constr.datalen; k++) {
13408 uint64_t _res_conv_10 = _res_vals[k];
13409 LDKRouteHop _res_conv_10_conv;
13410 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
13411 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
13412 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
13413 _res_constr.data[k] = _res_conv_10_conv;
13416 CVec_RouteHopZ_free(_res_constr);
13419 void __attribute__((export_name("TS_CVec_PathZ_free"))) TS_CVec_PathZ_free(uint64_tArray _res) {
13420 LDKCVec_PathZ _res_constr;
13421 _res_constr.datalen = _res->arr_len;
13422 if (_res_constr.datalen > 0)
13423 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
13425 _res_constr.data = NULL;
13426 uint64_t* _res_vals = _res->elems;
13427 for (size_t g = 0; g < _res_constr.datalen; g++) {
13428 uint64_t _res_conv_6 = _res_vals[g];
13429 LDKPath _res_conv_6_conv;
13430 _res_conv_6_conv.inner = untag_ptr(_res_conv_6);
13431 _res_conv_6_conv.is_owned = ptr_is_owned(_res_conv_6);
13432 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_6_conv);
13433 _res_constr.data[g] = _res_conv_6_conv;
13436 CVec_PathZ_free(_res_constr);
13439 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_ok"))) TS_CResult_RouteDecodeErrorZ_ok(uint64_t o) {
13441 o_conv.inner = untag_ptr(o);
13442 o_conv.is_owned = ptr_is_owned(o);
13443 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13444 o_conv = Route_clone(&o_conv);
13445 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13446 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
13447 return tag_ptr(ret_conv, true);
13450 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_err"))) TS_CResult_RouteDecodeErrorZ_err(uint64_t e) {
13451 void* e_ptr = untag_ptr(e);
13452 CHECK_ACCESS(e_ptr);
13453 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13454 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13455 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13456 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
13457 return tag_ptr(ret_conv, true);
13460 jboolean __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_is_ok"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint64_t o) {
13461 LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(o);
13462 jboolean ret_conv = CResult_RouteDecodeErrorZ_is_ok(o_conv);
13466 void __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_free"))) TS_CResult_RouteDecodeErrorZ_free(uint64_t _res) {
13467 if (!ptr_is_owned(_res)) return;
13468 void* _res_ptr = untag_ptr(_res);
13469 CHECK_ACCESS(_res_ptr);
13470 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(_res_ptr);
13471 FREE(untag_ptr(_res));
13472 CResult_RouteDecodeErrorZ_free(_res_conv);
13475 static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
13476 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13477 *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
13478 return tag_ptr(ret_conv, true);
13480 int64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone_ptr"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint64_t arg) {
13481 LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(arg);
13482 int64_t ret_conv = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
13486 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone"))) TS_CResult_RouteDecodeErrorZ_clone(uint64_t orig) {
13487 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(orig);
13488 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
13489 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
13490 return tag_ptr(ret_conv, true);
13493 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_ok"))) TS_CResult_RouteParametersDecodeErrorZ_ok(uint64_t o) {
13494 LDKRouteParameters o_conv;
13495 o_conv.inner = untag_ptr(o);
13496 o_conv.is_owned = ptr_is_owned(o);
13497 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13498 o_conv = RouteParameters_clone(&o_conv);
13499 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13500 *ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
13501 return tag_ptr(ret_conv, true);
13504 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_err"))) TS_CResult_RouteParametersDecodeErrorZ_err(uint64_t e) {
13505 void* e_ptr = untag_ptr(e);
13506 CHECK_ACCESS(e_ptr);
13507 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13508 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13509 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13510 *ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
13511 return tag_ptr(ret_conv, true);
13514 jboolean __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_is_ok"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint64_t o) {
13515 LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(o);
13516 jboolean ret_conv = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
13520 void __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_free"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint64_t _res) {
13521 if (!ptr_is_owned(_res)) return;
13522 void* _res_ptr = untag_ptr(_res);
13523 CHECK_ACCESS(_res_ptr);
13524 LDKCResult_RouteParametersDecodeErrorZ _res_conv = *(LDKCResult_RouteParametersDecodeErrorZ*)(_res_ptr);
13525 FREE(untag_ptr(_res));
13526 CResult_RouteParametersDecodeErrorZ_free(_res_conv);
13529 static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
13530 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13531 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
13532 return tag_ptr(ret_conv, true);
13534 int64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone_ptr"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
13535 LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(arg);
13536 int64_t ret_conv = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
13540 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint64_t orig) {
13541 LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(orig);
13542 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
13543 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(orig_conv);
13544 return tag_ptr(ret_conv, true);
13547 void __attribute__((export_name("TS_CVec_u64Z_free"))) TS_CVec_u64Z_free(int64_tArray _res) {
13548 LDKCVec_u64Z _res_constr;
13549 _res_constr.datalen = _res->arr_len;
13550 if (_res_constr.datalen > 0)
13551 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
13553 _res_constr.data = NULL;
13554 int64_t* _res_vals = _res->elems;
13555 for (size_t i = 0; i < _res_constr.datalen; i++) {
13556 int64_t _res_conv_8 = _res_vals[i];
13557 _res_constr.data[i] = _res_conv_8;
13560 CVec_u64Z_free(_res_constr);
13563 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_ok(uint64_t o) {
13564 LDKPaymentParameters o_conv;
13565 o_conv.inner = untag_ptr(o);
13566 o_conv.is_owned = ptr_is_owned(o);
13567 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13568 o_conv = PaymentParameters_clone(&o_conv);
13569 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13570 *ret_conv = CResult_PaymentParametersDecodeErrorZ_ok(o_conv);
13571 return tag_ptr(ret_conv, true);
13574 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_err"))) TS_CResult_PaymentParametersDecodeErrorZ_err(uint64_t e) {
13575 void* e_ptr = untag_ptr(e);
13576 CHECK_ACCESS(e_ptr);
13577 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13578 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13579 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13580 *ret_conv = CResult_PaymentParametersDecodeErrorZ_err(e_conv);
13581 return tag_ptr(ret_conv, true);
13584 jboolean __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_is_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_is_ok(uint64_t o) {
13585 LDKCResult_PaymentParametersDecodeErrorZ* o_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(o);
13586 jboolean ret_conv = CResult_PaymentParametersDecodeErrorZ_is_ok(o_conv);
13590 void __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_free"))) TS_CResult_PaymentParametersDecodeErrorZ_free(uint64_t _res) {
13591 if (!ptr_is_owned(_res)) return;
13592 void* _res_ptr = untag_ptr(_res);
13593 CHECK_ACCESS(_res_ptr);
13594 LDKCResult_PaymentParametersDecodeErrorZ _res_conv = *(LDKCResult_PaymentParametersDecodeErrorZ*)(_res_ptr);
13595 FREE(untag_ptr(_res));
13596 CResult_PaymentParametersDecodeErrorZ_free(_res_conv);
13599 static inline uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg) {
13600 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13601 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(arg);
13602 return tag_ptr(ret_conv, true);
13604 int64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
13605 LDKCResult_PaymentParametersDecodeErrorZ* arg_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(arg);
13606 int64_t ret_conv = CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg_conv);
13610 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone"))) TS_CResult_PaymentParametersDecodeErrorZ_clone(uint64_t orig) {
13611 LDKCResult_PaymentParametersDecodeErrorZ* orig_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(orig);
13612 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
13613 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(orig_conv);
13614 return tag_ptr(ret_conv, true);
13617 static inline uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg) {
13618 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
13619 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(arg);
13620 return tag_ptr(ret_conv, true);
13622 int64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(uint64_t arg) {
13623 LDKC2Tuple_BlindedPayInfoBlindedPathZ* arg_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(arg);
13624 int64_t ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg_conv);
13628 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(uint64_t orig) {
13629 LDKC2Tuple_BlindedPayInfoBlindedPathZ* orig_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(orig);
13630 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
13631 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig_conv);
13632 return tag_ptr(ret_conv, true);
13635 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_new"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(uint64_t a, uint64_t b) {
13636 LDKBlindedPayInfo a_conv;
13637 a_conv.inner = untag_ptr(a);
13638 a_conv.is_owned = ptr_is_owned(a);
13639 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
13640 a_conv = BlindedPayInfo_clone(&a_conv);
13641 LDKBlindedPath b_conv;
13642 b_conv.inner = untag_ptr(b);
13643 b_conv.is_owned = ptr_is_owned(b);
13644 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
13645 b_conv = BlindedPath_clone(&b_conv);
13646 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
13647 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_new(a_conv, b_conv);
13648 return tag_ptr(ret_conv, true);
13651 void __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_free"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(uint64_t _res) {
13652 if (!ptr_is_owned(_res)) return;
13653 void* _res_ptr = untag_ptr(_res);
13654 CHECK_ACCESS(_res_ptr);
13655 LDKC2Tuple_BlindedPayInfoBlindedPathZ _res_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(_res_ptr);
13656 FREE(untag_ptr(_res));
13657 C2Tuple_BlindedPayInfoBlindedPathZ_free(_res_conv);
13660 void __attribute__((export_name("TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free"))) TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(uint64_tArray _res) {
13661 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res_constr;
13662 _res_constr.datalen = _res->arr_len;
13663 if (_res_constr.datalen > 0)
13664 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
13666 _res_constr.data = NULL;
13667 uint64_t* _res_vals = _res->elems;
13668 for (size_t l = 0; l < _res_constr.datalen; l++) {
13669 uint64_t _res_conv_37 = _res_vals[l];
13670 void* _res_conv_37_ptr = untag_ptr(_res_conv_37);
13671 CHECK_ACCESS(_res_conv_37_ptr);
13672 LDKC2Tuple_BlindedPayInfoBlindedPathZ _res_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(_res_conv_37_ptr);
13673 FREE(untag_ptr(_res_conv_37));
13674 _res_constr.data[l] = _res_conv_37_conv;
13677 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res_constr);
13680 void __attribute__((export_name("TS_CVec_RouteHintZ_free"))) TS_CVec_RouteHintZ_free(uint64_tArray _res) {
13681 LDKCVec_RouteHintZ _res_constr;
13682 _res_constr.datalen = _res->arr_len;
13683 if (_res_constr.datalen > 0)
13684 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
13686 _res_constr.data = NULL;
13687 uint64_t* _res_vals = _res->elems;
13688 for (size_t l = 0; l < _res_constr.datalen; l++) {
13689 uint64_t _res_conv_11 = _res_vals[l];
13690 LDKRouteHint _res_conv_11_conv;
13691 _res_conv_11_conv.inner = untag_ptr(_res_conv_11);
13692 _res_conv_11_conv.is_owned = ptr_is_owned(_res_conv_11);
13693 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
13694 _res_constr.data[l] = _res_conv_11_conv;
13697 CVec_RouteHintZ_free(_res_constr);
13700 void __attribute__((export_name("TS_CVec_RouteHintHopZ_free"))) TS_CVec_RouteHintHopZ_free(uint64_tArray _res) {
13701 LDKCVec_RouteHintHopZ _res_constr;
13702 _res_constr.datalen = _res->arr_len;
13703 if (_res_constr.datalen > 0)
13704 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
13706 _res_constr.data = NULL;
13707 uint64_t* _res_vals = _res->elems;
13708 for (size_t o = 0; o < _res_constr.datalen; o++) {
13709 uint64_t _res_conv_14 = _res_vals[o];
13710 LDKRouteHintHop _res_conv_14_conv;
13711 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
13712 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
13713 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
13714 _res_constr.data[o] = _res_conv_14_conv;
13717 CVec_RouteHintHopZ_free(_res_constr);
13720 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_ok"))) TS_CResult_RouteHintDecodeErrorZ_ok(uint64_t o) {
13721 LDKRouteHint o_conv;
13722 o_conv.inner = untag_ptr(o);
13723 o_conv.is_owned = ptr_is_owned(o);
13724 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13725 o_conv = RouteHint_clone(&o_conv);
13726 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13727 *ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
13728 return tag_ptr(ret_conv, true);
13731 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_err"))) TS_CResult_RouteHintDecodeErrorZ_err(uint64_t e) {
13732 void* e_ptr = untag_ptr(e);
13733 CHECK_ACCESS(e_ptr);
13734 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13735 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13736 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13737 *ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
13738 return tag_ptr(ret_conv, true);
13741 jboolean __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_is_ok"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint64_t o) {
13742 LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(o);
13743 jboolean ret_conv = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
13747 void __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_free"))) TS_CResult_RouteHintDecodeErrorZ_free(uint64_t _res) {
13748 if (!ptr_is_owned(_res)) return;
13749 void* _res_ptr = untag_ptr(_res);
13750 CHECK_ACCESS(_res_ptr);
13751 LDKCResult_RouteHintDecodeErrorZ _res_conv = *(LDKCResult_RouteHintDecodeErrorZ*)(_res_ptr);
13752 FREE(untag_ptr(_res));
13753 CResult_RouteHintDecodeErrorZ_free(_res_conv);
13756 static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
13757 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13758 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
13759 return tag_ptr(ret_conv, true);
13761 int64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint64_t arg) {
13762 LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(arg);
13763 int64_t ret_conv = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
13767 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint64_t orig) {
13768 LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(orig);
13769 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
13770 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(orig_conv);
13771 return tag_ptr(ret_conv, true);
13774 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_ok(uint64_t o) {
13775 LDKRouteHintHop o_conv;
13776 o_conv.inner = untag_ptr(o);
13777 o_conv.is_owned = ptr_is_owned(o);
13778 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13779 o_conv = RouteHintHop_clone(&o_conv);
13780 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13781 *ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
13782 return tag_ptr(ret_conv, true);
13785 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_err"))) TS_CResult_RouteHintHopDecodeErrorZ_err(uint64_t e) {
13786 void* e_ptr = untag_ptr(e);
13787 CHECK_ACCESS(e_ptr);
13788 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
13789 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
13790 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13791 *ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
13792 return tag_ptr(ret_conv, true);
13795 jboolean __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint64_t o) {
13796 LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(o);
13797 jboolean ret_conv = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
13801 void __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_free"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint64_t _res) {
13802 if (!ptr_is_owned(_res)) return;
13803 void* _res_ptr = untag_ptr(_res);
13804 CHECK_ACCESS(_res_ptr);
13805 LDKCResult_RouteHintHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHintHopDecodeErrorZ*)(_res_ptr);
13806 FREE(untag_ptr(_res));
13807 CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
13810 static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
13811 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13812 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
13813 return tag_ptr(ret_conv, true);
13815 int64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint64_t arg) {
13816 LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(arg);
13817 int64_t ret_conv = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
13821 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint64_t orig) {
13822 LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(orig);
13823 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
13824 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(orig_conv);
13825 return tag_ptr(ret_conv, true);
13828 void __attribute__((export_name("TS_CVec_PublicKeyZ_free"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
13829 LDKCVec_PublicKeyZ _res_constr;
13830 _res_constr.datalen = _res->arr_len;
13831 if (_res_constr.datalen > 0)
13832 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
13834 _res_constr.data = NULL;
13835 int8_tArray* _res_vals = (void*) _res->elems;
13836 for (size_t m = 0; m < _res_constr.datalen; m++) {
13837 int8_tArray _res_conv_12 = _res_vals[m];
13838 LDKPublicKey _res_conv_12_ref;
13839 CHECK(_res_conv_12->arr_len == 33);
13840 memcpy(_res_conv_12_ref.compressed_form, _res_conv_12->elems, 33); FREE(_res_conv_12);
13841 _res_constr.data[m] = _res_conv_12_ref;
13844 CVec_PublicKeyZ_free(_res_constr);
13847 static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
13848 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13849 *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
13850 return tag_ptr(ret_conv, true);
13852 int64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone_ptr"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint64_t arg) {
13853 LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(arg);
13854 int64_t ret_conv = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
13858 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone"))) TS_C2Tuple_usizeTransactionZ_clone(uint64_t orig) {
13859 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(orig);
13860 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13861 *ret_conv = C2Tuple_usizeTransactionZ_clone(orig_conv);
13862 return tag_ptr(ret_conv, true);
13865 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_new"))) TS_C2Tuple_usizeTransactionZ_new(uint32_t a, int8_tArray b) {
13866 LDKTransaction b_ref;
13867 b_ref.datalen = b->arr_len;
13868 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
13869 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
13870 b_ref.data_is_owned = true;
13871 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13872 *ret_conv = C2Tuple_usizeTransactionZ_new(a, b_ref);
13873 return tag_ptr(ret_conv, true);
13876 void __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_free"))) TS_C2Tuple_usizeTransactionZ_free(uint64_t _res) {
13877 if (!ptr_is_owned(_res)) return;
13878 void* _res_ptr = untag_ptr(_res);
13879 CHECK_ACCESS(_res_ptr);
13880 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_ptr);
13881 FREE(untag_ptr(_res));
13882 C2Tuple_usizeTransactionZ_free(_res_conv);
13885 void __attribute__((export_name("TS_CVec_C2Tuple_usizeTransactionZZ_free"))) TS_CVec_C2Tuple_usizeTransactionZZ_free(uint64_tArray _res) {
13886 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
13887 _res_constr.datalen = _res->arr_len;
13888 if (_res_constr.datalen > 0)
13889 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
13891 _res_constr.data = NULL;
13892 uint64_t* _res_vals = _res->elems;
13893 for (size_t c = 0; c < _res_constr.datalen; c++) {
13894 uint64_t _res_conv_28 = _res_vals[c];
13895 void* _res_conv_28_ptr = untag_ptr(_res_conv_28);
13896 CHECK_ACCESS(_res_conv_28_ptr);
13897 LDKC2Tuple_usizeTransactionZ _res_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_conv_28_ptr);
13898 FREE(untag_ptr(_res_conv_28));
13899 _res_constr.data[c] = _res_conv_28_conv;
13902 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
13905 static inline uint64_t C2Tuple_TxidBlockHashZ_clone_ptr(LDKC2Tuple_TxidBlockHashZ *NONNULL_PTR arg) {
13906 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13907 *ret_conv = C2Tuple_TxidBlockHashZ_clone(arg);
13908 return tag_ptr(ret_conv, true);
13910 int64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_clone_ptr"))) TS_C2Tuple_TxidBlockHashZ_clone_ptr(uint64_t arg) {
13911 LDKC2Tuple_TxidBlockHashZ* arg_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(arg);
13912 int64_t ret_conv = C2Tuple_TxidBlockHashZ_clone_ptr(arg_conv);
13916 uint64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_clone"))) TS_C2Tuple_TxidBlockHashZ_clone(uint64_t orig) {
13917 LDKC2Tuple_TxidBlockHashZ* orig_conv = (LDKC2Tuple_TxidBlockHashZ*)untag_ptr(orig);
13918 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13919 *ret_conv = C2Tuple_TxidBlockHashZ_clone(orig_conv);
13920 return tag_ptr(ret_conv, true);
13923 uint64_t __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_new"))) TS_C2Tuple_TxidBlockHashZ_new(int8_tArray a, int8_tArray b) {
13924 LDKThirtyTwoBytes a_ref;
13925 CHECK(a->arr_len == 32);
13926 memcpy(a_ref.data, a->elems, 32); FREE(a);
13927 LDKThirtyTwoBytes b_ref;
13928 CHECK(b->arr_len == 32);
13929 memcpy(b_ref.data, b->elems, 32); FREE(b);
13930 LDKC2Tuple_TxidBlockHashZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
13931 *ret_conv = C2Tuple_TxidBlockHashZ_new(a_ref, b_ref);
13932 return tag_ptr(ret_conv, true);
13935 void __attribute__((export_name("TS_C2Tuple_TxidBlockHashZ_free"))) TS_C2Tuple_TxidBlockHashZ_free(uint64_t _res) {
13936 if (!ptr_is_owned(_res)) return;
13937 void* _res_ptr = untag_ptr(_res);
13938 CHECK_ACCESS(_res_ptr);
13939 LDKC2Tuple_TxidBlockHashZ _res_conv = *(LDKC2Tuple_TxidBlockHashZ*)(_res_ptr);
13940 FREE(untag_ptr(_res));
13941 C2Tuple_TxidBlockHashZ_free(_res_conv);
13944 void __attribute__((export_name("TS_CVec_C2Tuple_TxidBlockHashZZ_free"))) TS_CVec_C2Tuple_TxidBlockHashZZ_free(uint64_tArray _res) {
13945 LDKCVec_C2Tuple_TxidBlockHashZZ _res_constr;
13946 _res_constr.datalen = _res->arr_len;
13947 if (_res_constr.datalen > 0)
13948 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKCVec_C2Tuple_TxidBlockHashZZ Elements");
13950 _res_constr.data = NULL;
13951 uint64_t* _res_vals = _res->elems;
13952 for (size_t z = 0; z < _res_constr.datalen; z++) {
13953 uint64_t _res_conv_25 = _res_vals[z];
13954 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
13955 CHECK_ACCESS(_res_conv_25_ptr);
13956 LDKC2Tuple_TxidBlockHashZ _res_conv_25_conv = *(LDKC2Tuple_TxidBlockHashZ*)(_res_conv_25_ptr);
13957 FREE(untag_ptr(_res_conv_25));
13958 _res_constr.data[z] = _res_conv_25_conv;
13961 CVec_C2Tuple_TxidBlockHashZZ_free(_res_constr);
13964 void __attribute__((export_name("TS_CVec_MonitorEventZ_free"))) TS_CVec_MonitorEventZ_free(uint64_tArray _res) {
13965 LDKCVec_MonitorEventZ _res_constr;
13966 _res_constr.datalen = _res->arr_len;
13967 if (_res_constr.datalen > 0)
13968 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
13970 _res_constr.data = NULL;
13971 uint64_t* _res_vals = _res->elems;
13972 for (size_t o = 0; o < _res_constr.datalen; o++) {
13973 uint64_t _res_conv_14 = _res_vals[o];
13974 void* _res_conv_14_ptr = untag_ptr(_res_conv_14);
13975 CHECK_ACCESS(_res_conv_14_ptr);
13976 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(_res_conv_14_ptr);
13977 FREE(untag_ptr(_res_conv_14));
13978 _res_constr.data[o] = _res_conv_14_conv;
13981 CVec_MonitorEventZ_free(_res_constr);
13984 static inline uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg) {
13985 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13986 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(arg);
13987 return tag_ptr(ret_conv, true);
13989 int64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(uint64_t arg) {
13990 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* arg_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(arg);
13991 int64_t ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg_conv);
13995 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(uint64_t orig) {
13996 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* orig_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(orig);
13997 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13998 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig_conv);
13999 return tag_ptr(ret_conv, true);
14002 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(uint64_t a, uint64_tArray b, int8_tArray c) {
14003 LDKOutPoint a_conv;
14004 a_conv.inner = untag_ptr(a);
14005 a_conv.is_owned = ptr_is_owned(a);
14006 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
14007 a_conv = OutPoint_clone(&a_conv);
14008 LDKCVec_MonitorEventZ b_constr;
14009 b_constr.datalen = b->arr_len;
14010 if (b_constr.datalen > 0)
14011 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
14013 b_constr.data = NULL;
14014 uint64_t* b_vals = b->elems;
14015 for (size_t o = 0; o < b_constr.datalen; o++) {
14016 uint64_t b_conv_14 = b_vals[o];
14017 void* b_conv_14_ptr = untag_ptr(b_conv_14);
14018 CHECK_ACCESS(b_conv_14_ptr);
14019 LDKMonitorEvent b_conv_14_conv = *(LDKMonitorEvent*)(b_conv_14_ptr);
14020 b_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(b_conv_14));
14021 b_constr.data[o] = b_conv_14_conv;
14024 LDKPublicKey c_ref;
14025 CHECK(c->arr_len == 33);
14026 memcpy(c_ref.compressed_form, c->elems, 33); FREE(c);
14027 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
14028 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a_conv, b_constr, c_ref);
14029 return tag_ptr(ret_conv, true);
14032 void __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(uint64_t _res) {
14033 if (!ptr_is_owned(_res)) return;
14034 void* _res_ptr = untag_ptr(_res);
14035 CHECK_ACCESS(_res_ptr);
14036 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_ptr);
14037 FREE(untag_ptr(_res));
14038 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res_conv);
14041 void __attribute__((export_name("TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free"))) TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(uint64_tArray _res) {
14042 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res_constr;
14043 _res_constr.datalen = _res->arr_len;
14044 if (_res_constr.datalen > 0)
14045 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
14047 _res_constr.data = NULL;
14048 uint64_t* _res_vals = _res->elems;
14049 for (size_t x = 0; x < _res_constr.datalen; x++) {
14050 uint64_t _res_conv_49 = _res_vals[x];
14051 void* _res_conv_49_ptr = untag_ptr(_res_conv_49);
14052 CHECK_ACCESS(_res_conv_49_ptr);
14053 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_conv_49_ptr);
14054 FREE(untag_ptr(_res_conv_49));
14055 _res_constr.data[x] = _res_conv_49_conv;
14058 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res_constr);
14061 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(uint64_t o) {
14062 LDKFixedPenaltyScorer o_conv;
14063 o_conv.inner = untag_ptr(o);
14064 o_conv.is_owned = ptr_is_owned(o);
14065 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14066 o_conv = FixedPenaltyScorer_clone(&o_conv);
14067 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14068 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_ok(o_conv);
14069 return tag_ptr(ret_conv, true);
14072 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(uint64_t e) {
14073 void* e_ptr = untag_ptr(e);
14074 CHECK_ACCESS(e_ptr);
14075 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14076 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14077 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14078 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_err(e_conv);
14079 return tag_ptr(ret_conv, true);
14082 jboolean __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(uint64_t o) {
14083 LDKCResult_FixedPenaltyScorerDecodeErrorZ* o_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(o);
14084 jboolean ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o_conv);
14088 void __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_free"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(uint64_t _res) {
14089 if (!ptr_is_owned(_res)) return;
14090 void* _res_ptr = untag_ptr(_res);
14091 CHECK_ACCESS(_res_ptr);
14092 LDKCResult_FixedPenaltyScorerDecodeErrorZ _res_conv = *(LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(_res_ptr);
14093 FREE(untag_ptr(_res));
14094 CResult_FixedPenaltyScorerDecodeErrorZ_free(_res_conv);
14097 static inline uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg) {
14098 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14099 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(arg);
14100 return tag_ptr(ret_conv, true);
14102 int64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(uint64_t arg) {
14103 LDKCResult_FixedPenaltyScorerDecodeErrorZ* arg_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(arg);
14104 int64_t ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg_conv);
14108 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(uint64_t orig) {
14109 LDKCResult_FixedPenaltyScorerDecodeErrorZ* orig_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(orig);
14110 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
14111 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig_conv);
14112 return tag_ptr(ret_conv, true);
14115 static inline uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg) {
14116 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14117 *ret_conv = C2Tuple_u64u64Z_clone(arg);
14118 return tag_ptr(ret_conv, true);
14120 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone_ptr"))) TS_C2Tuple_u64u64Z_clone_ptr(uint64_t arg) {
14121 LDKC2Tuple_u64u64Z* arg_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(arg);
14122 int64_t ret_conv = C2Tuple_u64u64Z_clone_ptr(arg_conv);
14126 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone"))) TS_C2Tuple_u64u64Z_clone(uint64_t orig) {
14127 LDKC2Tuple_u64u64Z* orig_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(orig);
14128 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14129 *ret_conv = C2Tuple_u64u64Z_clone(orig_conv);
14130 return tag_ptr(ret_conv, true);
14133 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_new"))) TS_C2Tuple_u64u64Z_new(int64_t a, int64_t b) {
14134 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
14135 *ret_conv = C2Tuple_u64u64Z_new(a, b);
14136 return tag_ptr(ret_conv, true);
14139 void __attribute__((export_name("TS_C2Tuple_u64u64Z_free"))) TS_C2Tuple_u64u64Z_free(uint64_t _res) {
14140 if (!ptr_is_owned(_res)) return;
14141 void* _res_ptr = untag_ptr(_res);
14142 CHECK_ACCESS(_res_ptr);
14143 LDKC2Tuple_u64u64Z _res_conv = *(LDKC2Tuple_u64u64Z*)(_res_ptr);
14144 FREE(untag_ptr(_res));
14145 C2Tuple_u64u64Z_free(_res_conv);
14148 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_some"))) TS_COption_C2Tuple_u64u64ZZ_some(uint64_t o) {
14149 void* o_ptr = untag_ptr(o);
14150 CHECK_ACCESS(o_ptr);
14151 LDKC2Tuple_u64u64Z o_conv = *(LDKC2Tuple_u64u64Z*)(o_ptr);
14152 o_conv = C2Tuple_u64u64Z_clone((LDKC2Tuple_u64u64Z*)untag_ptr(o));
14153 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14154 *ret_copy = COption_C2Tuple_u64u64ZZ_some(o_conv);
14155 uint64_t ret_ref = tag_ptr(ret_copy, true);
14159 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_none"))) TS_COption_C2Tuple_u64u64ZZ_none() {
14160 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14161 *ret_copy = COption_C2Tuple_u64u64ZZ_none();
14162 uint64_t ret_ref = tag_ptr(ret_copy, true);
14166 void __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_free"))) TS_COption_C2Tuple_u64u64ZZ_free(uint64_t _res) {
14167 if (!ptr_is_owned(_res)) return;
14168 void* _res_ptr = untag_ptr(_res);
14169 CHECK_ACCESS(_res_ptr);
14170 LDKCOption_C2Tuple_u64u64ZZ _res_conv = *(LDKCOption_C2Tuple_u64u64ZZ*)(_res_ptr);
14171 FREE(untag_ptr(_res));
14172 COption_C2Tuple_u64u64ZZ_free(_res_conv);
14175 static inline uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg) {
14176 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14177 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(arg);
14178 uint64_t ret_ref = tag_ptr(ret_copy, true);
14181 int64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone_ptr"))) TS_COption_C2Tuple_u64u64ZZ_clone_ptr(uint64_t arg) {
14182 LDKCOption_C2Tuple_u64u64ZZ* arg_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(arg);
14183 int64_t ret_conv = COption_C2Tuple_u64u64ZZ_clone_ptr(arg_conv);
14187 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone"))) TS_COption_C2Tuple_u64u64ZZ_clone(uint64_t orig) {
14188 LDKCOption_C2Tuple_u64u64ZZ* orig_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(orig);
14189 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
14190 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(orig_conv);
14191 uint64_t ret_ref = tag_ptr(ret_copy, true);
14195 static inline uint64_t C2Tuple_Z_clone_ptr(LDKC2Tuple_Z *NONNULL_PTR arg) {
14196 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
14197 *ret_conv = C2Tuple_Z_clone(arg);
14198 return tag_ptr(ret_conv, true);
14200 int64_t __attribute__((export_name("TS_C2Tuple_Z_clone_ptr"))) TS_C2Tuple_Z_clone_ptr(uint64_t arg) {
14201 LDKC2Tuple_Z* arg_conv = (LDKC2Tuple_Z*)untag_ptr(arg);
14202 int64_t ret_conv = C2Tuple_Z_clone_ptr(arg_conv);
14206 uint64_t __attribute__((export_name("TS_C2Tuple_Z_clone"))) TS_C2Tuple_Z_clone(uint64_t orig) {
14207 LDKC2Tuple_Z* orig_conv = (LDKC2Tuple_Z*)untag_ptr(orig);
14208 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
14209 *ret_conv = C2Tuple_Z_clone(orig_conv);
14210 return tag_ptr(ret_conv, true);
14213 uint64_t __attribute__((export_name("TS_C2Tuple_Z_new"))) TS_C2Tuple_Z_new(int16_tArray a, int16_tArray b) {
14214 LDKEightU16s a_ref;
14215 CHECK(a->arr_len == 8);
14216 memcpy(a_ref.data, a->elems, 8 * 2); FREE(a);
14217 LDKEightU16s b_ref;
14218 CHECK(b->arr_len == 8);
14219 memcpy(b_ref.data, b->elems, 8 * 2); FREE(b);
14220 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
14221 *ret_conv = C2Tuple_Z_new(a_ref, b_ref);
14222 return tag_ptr(ret_conv, true);
14225 void __attribute__((export_name("TS_C2Tuple_Z_free"))) TS_C2Tuple_Z_free(uint64_t _res) {
14226 if (!ptr_is_owned(_res)) return;
14227 void* _res_ptr = untag_ptr(_res);
14228 CHECK_ACCESS(_res_ptr);
14229 LDKC2Tuple_Z _res_conv = *(LDKC2Tuple_Z*)(_res_ptr);
14230 FREE(untag_ptr(_res));
14231 C2Tuple_Z_free(_res_conv);
14234 static inline uint64_t C2Tuple__u168_u168Z_clone_ptr(LDKC2Tuple__u168_u168Z *NONNULL_PTR arg) {
14235 LDKC2Tuple__u168_u168Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
14236 *ret_conv = C2Tuple__u168_u168Z_clone(arg);
14237 return tag_ptr(ret_conv, true);
14239 int64_t __attribute__((export_name("TS_C2Tuple__u168_u168Z_clone_ptr"))) TS_C2Tuple__u168_u168Z_clone_ptr(uint64_t arg) {
14240 LDKC2Tuple__u168_u168Z* arg_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(arg);
14241 int64_t ret_conv = C2Tuple__u168_u168Z_clone_ptr(arg_conv);
14245 uint64_t __attribute__((export_name("TS_C2Tuple__u168_u168Z_clone"))) TS_C2Tuple__u168_u168Z_clone(uint64_t orig) {
14246 LDKC2Tuple__u168_u168Z* orig_conv = (LDKC2Tuple__u168_u168Z*)untag_ptr(orig);
14247 LDKC2Tuple__u168_u168Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
14248 *ret_conv = C2Tuple__u168_u168Z_clone(orig_conv);
14249 return tag_ptr(ret_conv, true);
14252 uint64_t __attribute__((export_name("TS_C2Tuple__u168_u168Z_new"))) TS_C2Tuple__u168_u168Z_new(int16_tArray a, int16_tArray b) {
14253 LDKEightU16s a_ref;
14254 CHECK(a->arr_len == 8);
14255 memcpy(a_ref.data, a->elems, 8 * 2); FREE(a);
14256 LDKEightU16s b_ref;
14257 CHECK(b->arr_len == 8);
14258 memcpy(b_ref.data, b->elems, 8 * 2); FREE(b);
14259 LDKC2Tuple__u168_u168Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u168_u168Z), "LDKC2Tuple__u168_u168Z");
14260 *ret_conv = C2Tuple__u168_u168Z_new(a_ref, b_ref);
14261 return tag_ptr(ret_conv, true);
14264 void __attribute__((export_name("TS_C2Tuple__u168_u168Z_free"))) TS_C2Tuple__u168_u168Z_free(uint64_t _res) {
14265 if (!ptr_is_owned(_res)) return;
14266 void* _res_ptr = untag_ptr(_res);
14267 CHECK_ACCESS(_res_ptr);
14268 LDKC2Tuple__u168_u168Z _res_conv = *(LDKC2Tuple__u168_u168Z*)(_res_ptr);
14269 FREE(untag_ptr(_res));
14270 C2Tuple__u168_u168Z_free(_res_conv);
14273 uint64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_some"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_some(uint64_t o) {
14274 void* o_ptr = untag_ptr(o);
14275 CHECK_ACCESS(o_ptr);
14276 LDKC2Tuple__u168_u168Z o_conv = *(LDKC2Tuple__u168_u168Z*)(o_ptr);
14277 o_conv = C2Tuple__u168_u168Z_clone((LDKC2Tuple__u168_u168Z*)untag_ptr(o));
14278 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14279 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_some(o_conv);
14280 uint64_t ret_ref = tag_ptr(ret_copy, true);
14284 uint64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_none"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_none() {
14285 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14286 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_none();
14287 uint64_t ret_ref = tag_ptr(ret_copy, true);
14291 void __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_free"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_free(uint64_t _res) {
14292 if (!ptr_is_owned(_res)) return;
14293 void* _res_ptr = untag_ptr(_res);
14294 CHECK_ACCESS(_res_ptr);
14295 LDKCOption_C2Tuple_EightU16sEightU16sZZ _res_conv = *(LDKCOption_C2Tuple_EightU16sEightU16sZZ*)(_res_ptr);
14296 FREE(untag_ptr(_res));
14297 COption_C2Tuple_EightU16sEightU16sZZ_free(_res_conv);
14300 static inline uint64_t COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(LDKCOption_C2Tuple_EightU16sEightU16sZZ *NONNULL_PTR arg) {
14301 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14302 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_clone(arg);
14303 uint64_t ret_ref = tag_ptr(ret_copy, true);
14306 int64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(uint64_t arg) {
14307 LDKCOption_C2Tuple_EightU16sEightU16sZZ* arg_conv = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(arg);
14308 int64_t ret_conv = COption_C2Tuple_EightU16sEightU16sZZ_clone_ptr(arg_conv);
14312 uint64_t __attribute__((export_name("TS_COption_C2Tuple_EightU16sEightU16sZZ_clone"))) TS_COption_C2Tuple_EightU16sEightU16sZZ_clone(uint64_t orig) {
14313 LDKCOption_C2Tuple_EightU16sEightU16sZZ* orig_conv = (LDKCOption_C2Tuple_EightU16sEightU16sZZ*)untag_ptr(orig);
14314 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
14315 *ret_copy = COption_C2Tuple_EightU16sEightU16sZZ_clone(orig_conv);
14316 uint64_t ret_ref = tag_ptr(ret_copy, true);
14320 void __attribute__((export_name("TS_CVec_NodeIdZ_free"))) TS_CVec_NodeIdZ_free(uint64_tArray _res) {
14321 LDKCVec_NodeIdZ _res_constr;
14322 _res_constr.datalen = _res->arr_len;
14323 if (_res_constr.datalen > 0)
14324 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
14326 _res_constr.data = NULL;
14327 uint64_t* _res_vals = _res->elems;
14328 for (size_t i = 0; i < _res_constr.datalen; i++) {
14329 uint64_t _res_conv_8 = _res_vals[i];
14330 LDKNodeId _res_conv_8_conv;
14331 _res_conv_8_conv.inner = untag_ptr(_res_conv_8);
14332 _res_conv_8_conv.is_owned = ptr_is_owned(_res_conv_8);
14333 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_8_conv);
14334 _res_constr.data[i] = _res_conv_8_conv;
14337 CVec_NodeIdZ_free(_res_constr);
14340 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(uint64_t o) {
14341 LDKProbabilisticScorer o_conv;
14342 o_conv.inner = untag_ptr(o);
14343 o_conv.is_owned = ptr_is_owned(o);
14344 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14345 // WARNING: we need a move here but no clone is available for LDKProbabilisticScorer
14347 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
14348 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_ok(o_conv);
14349 return tag_ptr(ret_conv, true);
14352 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_err(uint64_t e) {
14353 void* e_ptr = untag_ptr(e);
14354 CHECK_ACCESS(e_ptr);
14355 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14356 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14357 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
14358 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_err(e_conv);
14359 return tag_ptr(ret_conv, true);
14362 jboolean __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(uint64_t o) {
14363 LDKCResult_ProbabilisticScorerDecodeErrorZ* o_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(o);
14364 jboolean ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o_conv);
14368 void __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_free"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_free(uint64_t _res) {
14369 if (!ptr_is_owned(_res)) return;
14370 void* _res_ptr = untag_ptr(_res);
14371 CHECK_ACCESS(_res_ptr);
14372 LDKCResult_ProbabilisticScorerDecodeErrorZ _res_conv = *(LDKCResult_ProbabilisticScorerDecodeErrorZ*)(_res_ptr);
14373 FREE(untag_ptr(_res));
14374 CResult_ProbabilisticScorerDecodeErrorZ_free(_res_conv);
14377 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint64_t o) {
14378 LDKInitFeatures o_conv;
14379 o_conv.inner = untag_ptr(o);
14380 o_conv.is_owned = ptr_is_owned(o);
14381 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14382 o_conv = InitFeatures_clone(&o_conv);
14383 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14384 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
14385 return tag_ptr(ret_conv, true);
14388 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_err"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint64_t e) {
14389 void* e_ptr = untag_ptr(e);
14390 CHECK_ACCESS(e_ptr);
14391 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14392 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14393 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14394 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
14395 return tag_ptr(ret_conv, true);
14398 jboolean __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14399 LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(o);
14400 jboolean ret_conv = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
14404 void __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_free"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint64_t _res) {
14405 if (!ptr_is_owned(_res)) return;
14406 void* _res_ptr = untag_ptr(_res);
14407 CHECK_ACCESS(_res_ptr);
14408 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(_res_ptr);
14409 FREE(untag_ptr(_res));
14410 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
14413 static inline uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14414 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14415 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(arg);
14416 return tag_ptr(ret_conv, true);
14418 int64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14419 LDKCResult_InitFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(arg);
14420 int64_t ret_conv = CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14424 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone"))) TS_CResult_InitFeaturesDecodeErrorZ_clone(uint64_t orig) {
14425 LDKCResult_InitFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(orig);
14426 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
14427 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(orig_conv);
14428 return tag_ptr(ret_conv, true);
14431 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint64_t o) {
14432 LDKChannelFeatures o_conv;
14433 o_conv.inner = untag_ptr(o);
14434 o_conv.is_owned = ptr_is_owned(o);
14435 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14436 o_conv = ChannelFeatures_clone(&o_conv);
14437 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14438 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
14439 return tag_ptr(ret_conv, true);
14442 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint64_t e) {
14443 void* e_ptr = untag_ptr(e);
14444 CHECK_ACCESS(e_ptr);
14445 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14446 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14447 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14448 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
14449 return tag_ptr(ret_conv, true);
14452 jboolean __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14453 LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(o);
14454 jboolean ret_conv = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
14458 void __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint64_t _res) {
14459 if (!ptr_is_owned(_res)) return;
14460 void* _res_ptr = untag_ptr(_res);
14461 CHECK_ACCESS(_res_ptr);
14462 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(_res_ptr);
14463 FREE(untag_ptr(_res));
14464 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
14467 static inline uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14468 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14469 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(arg);
14470 return tag_ptr(ret_conv, true);
14472 int64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14473 LDKCResult_ChannelFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(arg);
14474 int64_t ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14478 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone(uint64_t orig) {
14479 LDKCResult_ChannelFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(orig);
14480 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14481 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(orig_conv);
14482 return tag_ptr(ret_conv, true);
14485 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint64_t o) {
14486 LDKNodeFeatures o_conv;
14487 o_conv.inner = untag_ptr(o);
14488 o_conv.is_owned = ptr_is_owned(o);
14489 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14490 o_conv = NodeFeatures_clone(&o_conv);
14491 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14492 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
14493 return tag_ptr(ret_conv, true);
14496 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint64_t e) {
14497 void* e_ptr = untag_ptr(e);
14498 CHECK_ACCESS(e_ptr);
14499 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14500 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14501 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14502 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
14503 return tag_ptr(ret_conv, true);
14506 jboolean __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14507 LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(o);
14508 jboolean ret_conv = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
14512 void __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_free"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint64_t _res) {
14513 if (!ptr_is_owned(_res)) return;
14514 void* _res_ptr = untag_ptr(_res);
14515 CHECK_ACCESS(_res_ptr);
14516 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(_res_ptr);
14517 FREE(untag_ptr(_res));
14518 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
14521 static inline uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14522 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14523 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(arg);
14524 return tag_ptr(ret_conv, true);
14526 int64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14527 LDKCResult_NodeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(arg);
14528 int64_t ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14532 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone(uint64_t orig) {
14533 LDKCResult_NodeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(orig);
14534 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14535 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(orig_conv);
14536 return tag_ptr(ret_conv, true);
14539 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(uint64_t o) {
14540 LDKInvoiceFeatures o_conv;
14541 o_conv.inner = untag_ptr(o);
14542 o_conv.is_owned = ptr_is_owned(o);
14543 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14544 o_conv = InvoiceFeatures_clone(&o_conv);
14545 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14546 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
14547 return tag_ptr(ret_conv, true);
14550 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_err(uint64_t e) {
14551 void* e_ptr = untag_ptr(e);
14552 CHECK_ACCESS(e_ptr);
14553 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14554 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14555 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14556 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
14557 return tag_ptr(ret_conv, true);
14560 jboolean __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14561 LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(o);
14562 jboolean ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
14566 void __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_free"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint64_t _res) {
14567 if (!ptr_is_owned(_res)) return;
14568 void* _res_ptr = untag_ptr(_res);
14569 CHECK_ACCESS(_res_ptr);
14570 LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
14571 FREE(untag_ptr(_res));
14572 CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
14575 static inline uint64_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14576 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14577 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(arg);
14578 return tag_ptr(ret_conv, true);
14580 int64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14581 LDKCResult_InvoiceFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(arg);
14582 int64_t ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14586 uint64_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(uint64_t orig) {
14587 LDKCResult_InvoiceFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)untag_ptr(orig);
14588 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14589 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(orig_conv);
14590 return tag_ptr(ret_conv, true);
14593 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(uint64_t o) {
14594 LDKBlindedHopFeatures o_conv;
14595 o_conv.inner = untag_ptr(o);
14596 o_conv.is_owned = ptr_is_owned(o);
14597 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14598 o_conv = BlindedHopFeatures_clone(&o_conv);
14599 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14600 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_ok(o_conv);
14601 return tag_ptr(ret_conv, true);
14604 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_err"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(uint64_t e) {
14605 void* e_ptr = untag_ptr(e);
14606 CHECK_ACCESS(e_ptr);
14607 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14608 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14609 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14610 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_err(e_conv);
14611 return tag_ptr(ret_conv, true);
14614 jboolean __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14615 LDKCResult_BlindedHopFeaturesDecodeErrorZ* o_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(o);
14616 jboolean ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o_conv);
14620 void __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_free"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(uint64_t _res) {
14621 if (!ptr_is_owned(_res)) return;
14622 void* _res_ptr = untag_ptr(_res);
14623 CHECK_ACCESS(_res_ptr);
14624 LDKCResult_BlindedHopFeaturesDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopFeaturesDecodeErrorZ*)(_res_ptr);
14625 FREE(untag_ptr(_res));
14626 CResult_BlindedHopFeaturesDecodeErrorZ_free(_res_conv);
14629 static inline uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14630 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14631 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone(arg);
14632 return tag_ptr(ret_conv, true);
14634 int64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14635 LDKCResult_BlindedHopFeaturesDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(arg);
14636 int64_t ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14640 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(uint64_t orig) {
14641 LDKCResult_BlindedHopFeaturesDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(orig);
14642 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
14643 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig_conv);
14644 return tag_ptr(ret_conv, true);
14647 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(uint64_t o) {
14648 LDKChannelTypeFeatures o_conv;
14649 o_conv.inner = untag_ptr(o);
14650 o_conv.is_owned = ptr_is_owned(o);
14651 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14652 o_conv = ChannelTypeFeatures_clone(&o_conv);
14653 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14654 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o_conv);
14655 return tag_ptr(ret_conv, true);
14658 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(uint64_t e) {
14659 void* e_ptr = untag_ptr(e);
14660 CHECK_ACCESS(e_ptr);
14661 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14662 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14663 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14664 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_err(e_conv);
14665 return tag_ptr(ret_conv, true);
14668 jboolean __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
14669 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(o);
14670 jboolean ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o_conv);
14674 void __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(uint64_t _res) {
14675 if (!ptr_is_owned(_res)) return;
14676 void* _res_ptr = untag_ptr(_res);
14677 CHECK_ACCESS(_res_ptr);
14678 LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(_res_ptr);
14679 FREE(untag_ptr(_res));
14680 CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res_conv);
14683 static inline uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14684 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14685 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(arg);
14686 return tag_ptr(ret_conv, true);
14688 int64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
14689 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(arg);
14690 int64_t ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14694 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(uint64_t orig) {
14695 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(orig);
14696 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14697 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig_conv);
14698 return tag_ptr(ret_conv, true);
14701 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_ok(uint64_t o) {
14702 void* o_ptr = untag_ptr(o);
14703 CHECK_ACCESS(o_ptr);
14704 LDKPaymentPurpose o_conv = *(LDKPaymentPurpose*)(o_ptr);
14705 o_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(o));
14706 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14707 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_ok(o_conv);
14708 return tag_ptr(ret_conv, true);
14711 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_err(uint64_t e) {
14712 void* e_ptr = untag_ptr(e);
14713 CHECK_ACCESS(e_ptr);
14714 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14715 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14716 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14717 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_err(e_conv);
14718 return tag_ptr(ret_conv, true);
14721 jboolean __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_is_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(uint64_t o) {
14722 LDKCResult_PaymentPurposeDecodeErrorZ* o_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(o);
14723 jboolean ret_conv = CResult_PaymentPurposeDecodeErrorZ_is_ok(o_conv);
14727 void __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_free"))) TS_CResult_PaymentPurposeDecodeErrorZ_free(uint64_t _res) {
14728 if (!ptr_is_owned(_res)) return;
14729 void* _res_ptr = untag_ptr(_res);
14730 CHECK_ACCESS(_res_ptr);
14731 LDKCResult_PaymentPurposeDecodeErrorZ _res_conv = *(LDKCResult_PaymentPurposeDecodeErrorZ*)(_res_ptr);
14732 FREE(untag_ptr(_res));
14733 CResult_PaymentPurposeDecodeErrorZ_free(_res_conv);
14736 static inline uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg) {
14737 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14738 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(arg);
14739 return tag_ptr(ret_conv, true);
14741 int64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(uint64_t arg) {
14742 LDKCResult_PaymentPurposeDecodeErrorZ* arg_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(arg);
14743 int64_t ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg_conv);
14747 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone(uint64_t orig) {
14748 LDKCResult_PaymentPurposeDecodeErrorZ* orig_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(orig);
14749 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
14750 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(orig_conv);
14751 return tag_ptr(ret_conv, true);
14754 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_some"))) TS_COption_NetworkUpdateZ_some(uint64_t o) {
14755 void* o_ptr = untag_ptr(o);
14756 CHECK_ACCESS(o_ptr);
14757 LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(o_ptr);
14758 o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)untag_ptr(o));
14759 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14760 *ret_copy = COption_NetworkUpdateZ_some(o_conv);
14761 uint64_t ret_ref = tag_ptr(ret_copy, true);
14765 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_none"))) TS_COption_NetworkUpdateZ_none() {
14766 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14767 *ret_copy = COption_NetworkUpdateZ_none();
14768 uint64_t ret_ref = tag_ptr(ret_copy, true);
14772 void __attribute__((export_name("TS_COption_NetworkUpdateZ_free"))) TS_COption_NetworkUpdateZ_free(uint64_t _res) {
14773 if (!ptr_is_owned(_res)) return;
14774 void* _res_ptr = untag_ptr(_res);
14775 CHECK_ACCESS(_res_ptr);
14776 LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(_res_ptr);
14777 FREE(untag_ptr(_res));
14778 COption_NetworkUpdateZ_free(_res_conv);
14781 static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
14782 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14783 *ret_copy = COption_NetworkUpdateZ_clone(arg);
14784 uint64_t ret_ref = tag_ptr(ret_copy, true);
14787 int64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone_ptr"))) TS_COption_NetworkUpdateZ_clone_ptr(uint64_t arg) {
14788 LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(arg);
14789 int64_t ret_conv = COption_NetworkUpdateZ_clone_ptr(arg_conv);
14793 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone"))) TS_COption_NetworkUpdateZ_clone(uint64_t orig) {
14794 LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(orig);
14795 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
14796 *ret_copy = COption_NetworkUpdateZ_clone(orig_conv);
14797 uint64_t ret_ref = tag_ptr(ret_copy, true);
14801 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_some"))) TS_COption_PathFailureZ_some(uint64_t o) {
14802 void* o_ptr = untag_ptr(o);
14803 CHECK_ACCESS(o_ptr);
14804 LDKPathFailure o_conv = *(LDKPathFailure*)(o_ptr);
14805 o_conv = PathFailure_clone((LDKPathFailure*)untag_ptr(o));
14806 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14807 *ret_copy = COption_PathFailureZ_some(o_conv);
14808 uint64_t ret_ref = tag_ptr(ret_copy, true);
14812 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_none"))) TS_COption_PathFailureZ_none() {
14813 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14814 *ret_copy = COption_PathFailureZ_none();
14815 uint64_t ret_ref = tag_ptr(ret_copy, true);
14819 void __attribute__((export_name("TS_COption_PathFailureZ_free"))) TS_COption_PathFailureZ_free(uint64_t _res) {
14820 if (!ptr_is_owned(_res)) return;
14821 void* _res_ptr = untag_ptr(_res);
14822 CHECK_ACCESS(_res_ptr);
14823 LDKCOption_PathFailureZ _res_conv = *(LDKCOption_PathFailureZ*)(_res_ptr);
14824 FREE(untag_ptr(_res));
14825 COption_PathFailureZ_free(_res_conv);
14828 static inline uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg) {
14829 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14830 *ret_copy = COption_PathFailureZ_clone(arg);
14831 uint64_t ret_ref = tag_ptr(ret_copy, true);
14834 int64_t __attribute__((export_name("TS_COption_PathFailureZ_clone_ptr"))) TS_COption_PathFailureZ_clone_ptr(uint64_t arg) {
14835 LDKCOption_PathFailureZ* arg_conv = (LDKCOption_PathFailureZ*)untag_ptr(arg);
14836 int64_t ret_conv = COption_PathFailureZ_clone_ptr(arg_conv);
14840 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_clone"))) TS_COption_PathFailureZ_clone(uint64_t orig) {
14841 LDKCOption_PathFailureZ* orig_conv = (LDKCOption_PathFailureZ*)untag_ptr(orig);
14842 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
14843 *ret_copy = COption_PathFailureZ_clone(orig_conv);
14844 uint64_t ret_ref = tag_ptr(ret_copy, true);
14848 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_ok(uint64_t o) {
14849 void* o_ptr = untag_ptr(o);
14850 CHECK_ACCESS(o_ptr);
14851 LDKCOption_PathFailureZ o_conv = *(LDKCOption_PathFailureZ*)(o_ptr);
14852 o_conv = COption_PathFailureZ_clone((LDKCOption_PathFailureZ*)untag_ptr(o));
14853 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14854 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_ok(o_conv);
14855 return tag_ptr(ret_conv, true);
14858 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_err"))) TS_CResult_COption_PathFailureZDecodeErrorZ_err(uint64_t e) {
14859 void* e_ptr = untag_ptr(e);
14860 CHECK_ACCESS(e_ptr);
14861 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14862 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14863 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14864 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_err(e_conv);
14865 return tag_ptr(ret_conv, true);
14868 jboolean __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(uint64_t o) {
14869 LDKCResult_COption_PathFailureZDecodeErrorZ* o_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(o);
14870 jboolean ret_conv = CResult_COption_PathFailureZDecodeErrorZ_is_ok(o_conv);
14874 void __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_free"))) TS_CResult_COption_PathFailureZDecodeErrorZ_free(uint64_t _res) {
14875 if (!ptr_is_owned(_res)) return;
14876 void* _res_ptr = untag_ptr(_res);
14877 CHECK_ACCESS(_res_ptr);
14878 LDKCResult_COption_PathFailureZDecodeErrorZ _res_conv = *(LDKCResult_COption_PathFailureZDecodeErrorZ*)(_res_ptr);
14879 FREE(untag_ptr(_res));
14880 CResult_COption_PathFailureZDecodeErrorZ_free(_res_conv);
14883 static inline uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg) {
14884 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14885 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone(arg);
14886 return tag_ptr(ret_conv, true);
14888 int64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(uint64_t arg) {
14889 LDKCResult_COption_PathFailureZDecodeErrorZ* arg_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(arg);
14890 int64_t ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg_conv);
14894 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_clone"))) TS_CResult_COption_PathFailureZDecodeErrorZ_clone(uint64_t orig) {
14895 LDKCResult_COption_PathFailureZDecodeErrorZ* orig_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(orig);
14896 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
14897 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone(orig_conv);
14898 return tag_ptr(ret_conv, true);
14901 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_some"))) TS_COption_ClosureReasonZ_some(uint64_t o) {
14902 void* o_ptr = untag_ptr(o);
14903 CHECK_ACCESS(o_ptr);
14904 LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
14905 o_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(o));
14906 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14907 *ret_copy = COption_ClosureReasonZ_some(o_conv);
14908 uint64_t ret_ref = tag_ptr(ret_copy, true);
14912 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_none"))) TS_COption_ClosureReasonZ_none() {
14913 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14914 *ret_copy = COption_ClosureReasonZ_none();
14915 uint64_t ret_ref = tag_ptr(ret_copy, true);
14919 void __attribute__((export_name("TS_COption_ClosureReasonZ_free"))) TS_COption_ClosureReasonZ_free(uint64_t _res) {
14920 if (!ptr_is_owned(_res)) return;
14921 void* _res_ptr = untag_ptr(_res);
14922 CHECK_ACCESS(_res_ptr);
14923 LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
14924 FREE(untag_ptr(_res));
14925 COption_ClosureReasonZ_free(_res_conv);
14928 static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
14929 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14930 *ret_copy = COption_ClosureReasonZ_clone(arg);
14931 uint64_t ret_ref = tag_ptr(ret_copy, true);
14934 int64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone_ptr"))) TS_COption_ClosureReasonZ_clone_ptr(uint64_t arg) {
14935 LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(arg);
14936 int64_t ret_conv = COption_ClosureReasonZ_clone_ptr(arg_conv);
14940 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone"))) TS_COption_ClosureReasonZ_clone(uint64_t orig) {
14941 LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(orig);
14942 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
14943 *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
14944 uint64_t ret_ref = tag_ptr(ret_copy, true);
14948 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint64_t o) {
14949 void* o_ptr = untag_ptr(o);
14950 CHECK_ACCESS(o_ptr);
14951 LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
14952 o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)untag_ptr(o));
14953 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14954 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
14955 return tag_ptr(ret_conv, true);
14958 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint64_t e) {
14959 void* e_ptr = untag_ptr(e);
14960 CHECK_ACCESS(e_ptr);
14961 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
14962 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
14963 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14964 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
14965 return tag_ptr(ret_conv, true);
14968 jboolean __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint64_t o) {
14969 LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(o);
14970 jboolean ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
14974 void __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_free"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint64_t _res) {
14975 if (!ptr_is_owned(_res)) return;
14976 void* _res_ptr = untag_ptr(_res);
14977 CHECK_ACCESS(_res_ptr);
14978 LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
14979 FREE(untag_ptr(_res));
14980 CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
14983 static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
14984 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14985 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
14986 return tag_ptr(ret_conv, true);
14988 int64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint64_t arg) {
14989 LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(arg);
14990 int64_t ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
14994 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint64_t orig) {
14995 LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(orig);
14996 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
14997 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
14998 return tag_ptr(ret_conv, true);
15001 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_some"))) TS_COption_HTLCDestinationZ_some(uint64_t o) {
15002 void* o_ptr = untag_ptr(o);
15003 CHECK_ACCESS(o_ptr);
15004 LDKHTLCDestination o_conv = *(LDKHTLCDestination*)(o_ptr);
15005 o_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(o));
15006 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15007 *ret_copy = COption_HTLCDestinationZ_some(o_conv);
15008 uint64_t ret_ref = tag_ptr(ret_copy, true);
15012 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_none"))) TS_COption_HTLCDestinationZ_none() {
15013 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15014 *ret_copy = COption_HTLCDestinationZ_none();
15015 uint64_t ret_ref = tag_ptr(ret_copy, true);
15019 void __attribute__((export_name("TS_COption_HTLCDestinationZ_free"))) TS_COption_HTLCDestinationZ_free(uint64_t _res) {
15020 if (!ptr_is_owned(_res)) return;
15021 void* _res_ptr = untag_ptr(_res);
15022 CHECK_ACCESS(_res_ptr);
15023 LDKCOption_HTLCDestinationZ _res_conv = *(LDKCOption_HTLCDestinationZ*)(_res_ptr);
15024 FREE(untag_ptr(_res));
15025 COption_HTLCDestinationZ_free(_res_conv);
15028 static inline uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg) {
15029 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15030 *ret_copy = COption_HTLCDestinationZ_clone(arg);
15031 uint64_t ret_ref = tag_ptr(ret_copy, true);
15034 int64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone_ptr"))) TS_COption_HTLCDestinationZ_clone_ptr(uint64_t arg) {
15035 LDKCOption_HTLCDestinationZ* arg_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(arg);
15036 int64_t ret_conv = COption_HTLCDestinationZ_clone_ptr(arg_conv);
15040 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone"))) TS_COption_HTLCDestinationZ_clone(uint64_t orig) {
15041 LDKCOption_HTLCDestinationZ* orig_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(orig);
15042 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
15043 *ret_copy = COption_HTLCDestinationZ_clone(orig_conv);
15044 uint64_t ret_ref = tag_ptr(ret_copy, true);
15048 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(uint64_t o) {
15049 void* o_ptr = untag_ptr(o);
15050 CHECK_ACCESS(o_ptr);
15051 LDKCOption_HTLCDestinationZ o_conv = *(LDKCOption_HTLCDestinationZ*)(o_ptr);
15052 o_conv = COption_HTLCDestinationZ_clone((LDKCOption_HTLCDestinationZ*)untag_ptr(o));
15053 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15054 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o_conv);
15055 return tag_ptr(ret_conv, true);
15058 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(uint64_t e) {
15059 void* e_ptr = untag_ptr(e);
15060 CHECK_ACCESS(e_ptr);
15061 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15062 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15063 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15064 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_err(e_conv);
15065 return tag_ptr(ret_conv, true);
15068 jboolean __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(uint64_t o) {
15069 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* o_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(o);
15070 jboolean ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o_conv);
15074 void __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(uint64_t _res) {
15075 if (!ptr_is_owned(_res)) return;
15076 void* _res_ptr = untag_ptr(_res);
15077 CHECK_ACCESS(_res_ptr);
15078 LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res_conv = *(LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(_res_ptr);
15079 FREE(untag_ptr(_res));
15080 CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res_conv);
15083 static inline uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg) {
15084 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15085 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(arg);
15086 return tag_ptr(ret_conv, true);
15088 int64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(uint64_t arg) {
15089 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* arg_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(arg);
15090 int64_t ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg_conv);
15094 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(uint64_t orig) {
15095 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* orig_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(orig);
15096 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
15097 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig_conv);
15098 return tag_ptr(ret_conv, true);
15101 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(uint32_t o) {
15102 LDKPaymentFailureReason o_conv = LDKPaymentFailureReason_from_js(o);
15103 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15104 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_ok(o_conv);
15105 return tag_ptr(ret_conv, true);
15108 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_err"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_err(uint64_t e) {
15109 void* e_ptr = untag_ptr(e);
15110 CHECK_ACCESS(e_ptr);
15111 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15112 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15113 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15114 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_err(e_conv);
15115 return tag_ptr(ret_conv, true);
15118 jboolean __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(uint64_t o) {
15119 LDKCResult_PaymentFailureReasonDecodeErrorZ* o_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(o);
15120 jboolean ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o_conv);
15124 void __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_free"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_free(uint64_t _res) {
15125 if (!ptr_is_owned(_res)) return;
15126 void* _res_ptr = untag_ptr(_res);
15127 CHECK_ACCESS(_res_ptr);
15128 LDKCResult_PaymentFailureReasonDecodeErrorZ _res_conv = *(LDKCResult_PaymentFailureReasonDecodeErrorZ*)(_res_ptr);
15129 FREE(untag_ptr(_res));
15130 CResult_PaymentFailureReasonDecodeErrorZ_free(_res_conv);
15133 static inline uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg) {
15134 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15135 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone(arg);
15136 return tag_ptr(ret_conv, true);
15138 int64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(uint64_t arg) {
15139 LDKCResult_PaymentFailureReasonDecodeErrorZ* arg_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(arg);
15140 int64_t ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg_conv);
15144 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_clone"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(uint64_t orig) {
15145 LDKCResult_PaymentFailureReasonDecodeErrorZ* orig_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(orig);
15146 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
15147 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone(orig_conv);
15148 return tag_ptr(ret_conv, true);
15151 uint64_t __attribute__((export_name("TS_COption_u128Z_some"))) TS_COption_u128Z_some(int8_tArray o) {
15153 CHECK(o->arr_len == 16);
15154 memcpy(o_ref.le_bytes, o->elems, 16); FREE(o);
15155 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15156 *ret_copy = COption_u128Z_some(o_ref);
15157 uint64_t ret_ref = tag_ptr(ret_copy, true);
15161 uint64_t __attribute__((export_name("TS_COption_u128Z_none"))) TS_COption_u128Z_none() {
15162 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15163 *ret_copy = COption_u128Z_none();
15164 uint64_t ret_ref = tag_ptr(ret_copy, true);
15168 void __attribute__((export_name("TS_COption_u128Z_free"))) TS_COption_u128Z_free(uint64_t _res) {
15169 if (!ptr_is_owned(_res)) return;
15170 void* _res_ptr = untag_ptr(_res);
15171 CHECK_ACCESS(_res_ptr);
15172 LDKCOption_u128Z _res_conv = *(LDKCOption_u128Z*)(_res_ptr);
15173 FREE(untag_ptr(_res));
15174 COption_u128Z_free(_res_conv);
15177 static inline uint64_t COption_u128Z_clone_ptr(LDKCOption_u128Z *NONNULL_PTR arg) {
15178 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15179 *ret_copy = COption_u128Z_clone(arg);
15180 uint64_t ret_ref = tag_ptr(ret_copy, true);
15183 int64_t __attribute__((export_name("TS_COption_u128Z_clone_ptr"))) TS_COption_u128Z_clone_ptr(uint64_t arg) {
15184 LDKCOption_u128Z* arg_conv = (LDKCOption_u128Z*)untag_ptr(arg);
15185 int64_t ret_conv = COption_u128Z_clone_ptr(arg_conv);
15189 uint64_t __attribute__((export_name("TS_COption_u128Z_clone"))) TS_COption_u128Z_clone(uint64_t orig) {
15190 LDKCOption_u128Z* orig_conv = (LDKCOption_u128Z*)untag_ptr(orig);
15191 LDKCOption_u128Z *ret_copy = MALLOC(sizeof(LDKCOption_u128Z), "LDKCOption_u128Z");
15192 *ret_copy = COption_u128Z_clone(orig_conv);
15193 uint64_t ret_ref = tag_ptr(ret_copy, true);
15197 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_some"))) TS_COption_PaymentFailureReasonZ_some(uint32_t o) {
15198 LDKPaymentFailureReason o_conv = LDKPaymentFailureReason_from_js(o);
15199 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15200 *ret_copy = COption_PaymentFailureReasonZ_some(o_conv);
15201 uint64_t ret_ref = tag_ptr(ret_copy, true);
15205 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_none"))) TS_COption_PaymentFailureReasonZ_none() {
15206 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15207 *ret_copy = COption_PaymentFailureReasonZ_none();
15208 uint64_t ret_ref = tag_ptr(ret_copy, true);
15212 void __attribute__((export_name("TS_COption_PaymentFailureReasonZ_free"))) TS_COption_PaymentFailureReasonZ_free(uint64_t _res) {
15213 if (!ptr_is_owned(_res)) return;
15214 void* _res_ptr = untag_ptr(_res);
15215 CHECK_ACCESS(_res_ptr);
15216 LDKCOption_PaymentFailureReasonZ _res_conv = *(LDKCOption_PaymentFailureReasonZ*)(_res_ptr);
15217 FREE(untag_ptr(_res));
15218 COption_PaymentFailureReasonZ_free(_res_conv);
15221 static inline uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg) {
15222 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15223 *ret_copy = COption_PaymentFailureReasonZ_clone(arg);
15224 uint64_t ret_ref = tag_ptr(ret_copy, true);
15227 int64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_clone_ptr"))) TS_COption_PaymentFailureReasonZ_clone_ptr(uint64_t arg) {
15228 LDKCOption_PaymentFailureReasonZ* arg_conv = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(arg);
15229 int64_t ret_conv = COption_PaymentFailureReasonZ_clone_ptr(arg_conv);
15233 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_clone"))) TS_COption_PaymentFailureReasonZ_clone(uint64_t orig) {
15234 LDKCOption_PaymentFailureReasonZ* orig_conv = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(orig);
15235 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
15236 *ret_copy = COption_PaymentFailureReasonZ_clone(orig_conv);
15237 uint64_t ret_ref = tag_ptr(ret_copy, true);
15241 void __attribute__((export_name("TS_CVec_SpendableOutputDescriptorZ_free"))) TS_CVec_SpendableOutputDescriptorZ_free(uint64_tArray _res) {
15242 LDKCVec_SpendableOutputDescriptorZ _res_constr;
15243 _res_constr.datalen = _res->arr_len;
15244 if (_res_constr.datalen > 0)
15245 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
15247 _res_constr.data = NULL;
15248 uint64_t* _res_vals = _res->elems;
15249 for (size_t b = 0; b < _res_constr.datalen; b++) {
15250 uint64_t _res_conv_27 = _res_vals[b];
15251 void* _res_conv_27_ptr = untag_ptr(_res_conv_27);
15252 CHECK_ACCESS(_res_conv_27_ptr);
15253 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(_res_conv_27_ptr);
15254 FREE(untag_ptr(_res_conv_27));
15255 _res_constr.data[b] = _res_conv_27_conv;
15258 CVec_SpendableOutputDescriptorZ_free(_res_constr);
15261 uint64_t __attribute__((export_name("TS_COption_EventZ_some"))) TS_COption_EventZ_some(uint64_t o) {
15262 void* o_ptr = untag_ptr(o);
15263 CHECK_ACCESS(o_ptr);
15264 LDKEvent o_conv = *(LDKEvent*)(o_ptr);
15265 o_conv = Event_clone((LDKEvent*)untag_ptr(o));
15266 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15267 *ret_copy = COption_EventZ_some(o_conv);
15268 uint64_t ret_ref = tag_ptr(ret_copy, true);
15272 uint64_t __attribute__((export_name("TS_COption_EventZ_none"))) TS_COption_EventZ_none() {
15273 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15274 *ret_copy = COption_EventZ_none();
15275 uint64_t ret_ref = tag_ptr(ret_copy, true);
15279 void __attribute__((export_name("TS_COption_EventZ_free"))) TS_COption_EventZ_free(uint64_t _res) {
15280 if (!ptr_is_owned(_res)) return;
15281 void* _res_ptr = untag_ptr(_res);
15282 CHECK_ACCESS(_res_ptr);
15283 LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
15284 FREE(untag_ptr(_res));
15285 COption_EventZ_free(_res_conv);
15288 static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
15289 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15290 *ret_copy = COption_EventZ_clone(arg);
15291 uint64_t ret_ref = tag_ptr(ret_copy, true);
15294 int64_t __attribute__((export_name("TS_COption_EventZ_clone_ptr"))) TS_COption_EventZ_clone_ptr(uint64_t arg) {
15295 LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)untag_ptr(arg);
15296 int64_t ret_conv = COption_EventZ_clone_ptr(arg_conv);
15300 uint64_t __attribute__((export_name("TS_COption_EventZ_clone"))) TS_COption_EventZ_clone(uint64_t orig) {
15301 LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)untag_ptr(orig);
15302 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
15303 *ret_copy = COption_EventZ_clone(orig_conv);
15304 uint64_t ret_ref = tag_ptr(ret_copy, true);
15308 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_ok"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint64_t o) {
15309 void* o_ptr = untag_ptr(o);
15310 CHECK_ACCESS(o_ptr);
15311 LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
15312 o_conv = COption_EventZ_clone((LDKCOption_EventZ*)untag_ptr(o));
15313 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15314 *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
15315 return tag_ptr(ret_conv, true);
15318 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_err"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint64_t e) {
15319 void* e_ptr = untag_ptr(e);
15320 CHECK_ACCESS(e_ptr);
15321 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15322 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15323 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15324 *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
15325 return tag_ptr(ret_conv, true);
15328 jboolean __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_is_ok"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint64_t o) {
15329 LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(o);
15330 jboolean ret_conv = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
15334 void __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_free"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint64_t _res) {
15335 if (!ptr_is_owned(_res)) return;
15336 void* _res_ptr = untag_ptr(_res);
15337 CHECK_ACCESS(_res_ptr);
15338 LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
15339 FREE(untag_ptr(_res));
15340 CResult_COption_EventZDecodeErrorZ_free(_res_conv);
15343 static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
15344 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15345 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
15346 return tag_ptr(ret_conv, true);
15348 int64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint64_t arg) {
15349 LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(arg);
15350 int64_t ret_conv = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
15354 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint64_t orig) {
15355 LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(orig);
15356 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
15357 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
15358 return tag_ptr(ret_conv, true);
15361 void __attribute__((export_name("TS_CVec_MessageSendEventZ_free"))) TS_CVec_MessageSendEventZ_free(uint64_tArray _res) {
15362 LDKCVec_MessageSendEventZ _res_constr;
15363 _res_constr.datalen = _res->arr_len;
15364 if (_res_constr.datalen > 0)
15365 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
15367 _res_constr.data = NULL;
15368 uint64_t* _res_vals = _res->elems;
15369 for (size_t s = 0; s < _res_constr.datalen; s++) {
15370 uint64_t _res_conv_18 = _res_vals[s];
15371 void* _res_conv_18_ptr = untag_ptr(_res_conv_18);
15372 CHECK_ACCESS(_res_conv_18_ptr);
15373 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(_res_conv_18_ptr);
15374 FREE(untag_ptr(_res_conv_18));
15375 _res_constr.data[s] = _res_conv_18_conv;
15378 CVec_MessageSendEventZ_free(_res_constr);
15381 void __attribute__((export_name("TS_CVec_ChainHashZ_free"))) TS_CVec_ChainHashZ_free(ptrArray _res) {
15382 LDKCVec_ChainHashZ _res_constr;
15383 _res_constr.datalen = _res->arr_len;
15384 if (_res_constr.datalen > 0)
15385 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ChainHashZ Elements");
15387 _res_constr.data = NULL;
15388 int8_tArray* _res_vals = (void*) _res->elems;
15389 for (size_t m = 0; m < _res_constr.datalen; m++) {
15390 int8_tArray _res_conv_12 = _res_vals[m];
15391 LDKThirtyTwoBytes _res_conv_12_ref;
15392 CHECK(_res_conv_12->arr_len == 32);
15393 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
15394 _res_constr.data[m] = _res_conv_12_ref;
15397 CVec_ChainHashZ_free(_res_constr);
15400 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_ok"))) TS_CResult_PublicKeyErrorZ_ok(int8_tArray o) {
15401 LDKPublicKey o_ref;
15402 CHECK(o->arr_len == 33);
15403 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
15404 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15405 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
15406 return tag_ptr(ret_conv, true);
15409 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_err"))) TS_CResult_PublicKeyErrorZ_err(uint32_t e) {
15410 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
15411 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15412 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
15413 return tag_ptr(ret_conv, true);
15416 jboolean __attribute__((export_name("TS_CResult_PublicKeyErrorZ_is_ok"))) TS_CResult_PublicKeyErrorZ_is_ok(uint64_t o) {
15417 LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(o);
15418 jboolean ret_conv = CResult_PublicKeyErrorZ_is_ok(o_conv);
15422 void __attribute__((export_name("TS_CResult_PublicKeyErrorZ_free"))) TS_CResult_PublicKeyErrorZ_free(uint64_t _res) {
15423 if (!ptr_is_owned(_res)) return;
15424 void* _res_ptr = untag_ptr(_res);
15425 CHECK_ACCESS(_res_ptr);
15426 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(_res_ptr);
15427 FREE(untag_ptr(_res));
15428 CResult_PublicKeyErrorZ_free(_res_conv);
15431 static inline uint64_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
15432 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15433 *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
15434 return tag_ptr(ret_conv, true);
15436 int64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone_ptr"))) TS_CResult_PublicKeyErrorZ_clone_ptr(uint64_t arg) {
15437 LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(arg);
15438 int64_t ret_conv = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
15442 uint64_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone"))) TS_CResult_PublicKeyErrorZ_clone(uint64_t orig) {
15443 LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)untag_ptr(orig);
15444 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
15445 *ret_conv = CResult_PublicKeyErrorZ_clone(orig_conv);
15446 return tag_ptr(ret_conv, true);
15449 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_ok"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint64_t o) {
15451 o_conv.inner = untag_ptr(o);
15452 o_conv.is_owned = ptr_is_owned(o);
15453 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15454 o_conv = NodeId_clone(&o_conv);
15455 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15456 *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
15457 return tag_ptr(ret_conv, true);
15460 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_err"))) TS_CResult_NodeIdDecodeErrorZ_err(uint64_t e) {
15461 void* e_ptr = untag_ptr(e);
15462 CHECK_ACCESS(e_ptr);
15463 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15464 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15465 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15466 *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
15467 return tag_ptr(ret_conv, true);
15470 jboolean __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_is_ok"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint64_t o) {
15471 LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(o);
15472 jboolean ret_conv = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
15476 void __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_free"))) TS_CResult_NodeIdDecodeErrorZ_free(uint64_t _res) {
15477 if (!ptr_is_owned(_res)) return;
15478 void* _res_ptr = untag_ptr(_res);
15479 CHECK_ACCESS(_res_ptr);
15480 LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
15481 FREE(untag_ptr(_res));
15482 CResult_NodeIdDecodeErrorZ_free(_res_conv);
15485 static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
15486 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15487 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
15488 return tag_ptr(ret_conv, true);
15490 int64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone_ptr"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint64_t arg) {
15491 LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(arg);
15492 int64_t ret_conv = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
15496 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint64_t orig) {
15497 LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(orig);
15498 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
15499 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
15500 return tag_ptr(ret_conv, true);
15503 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint64_t o) {
15504 void* o_ptr = untag_ptr(o);
15505 CHECK_ACCESS(o_ptr);
15506 LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
15507 o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(o));
15508 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15509 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
15510 return tag_ptr(ret_conv, true);
15513 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint64_t e) {
15514 void* e_ptr = untag_ptr(e);
15515 CHECK_ACCESS(e_ptr);
15516 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15517 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15518 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15519 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
15520 return tag_ptr(ret_conv, true);
15523 jboolean __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint64_t o) {
15524 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(o);
15525 jboolean ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
15529 void __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint64_t _res) {
15530 if (!ptr_is_owned(_res)) return;
15531 void* _res_ptr = untag_ptr(_res);
15532 CHECK_ACCESS(_res_ptr);
15533 LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
15534 FREE(untag_ptr(_res));
15535 CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
15538 static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
15539 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15540 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
15541 return tag_ptr(ret_conv, true);
15543 int64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint64_t arg) {
15544 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(arg);
15545 int64_t ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
15549 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint64_t orig) {
15550 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(orig);
15551 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
15552 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
15553 return tag_ptr(ret_conv, true);
15556 uint64_t __attribute__((export_name("TS_COption_UtxoLookupZ_some"))) TS_COption_UtxoLookupZ_some(uint64_t o) {
15557 void* o_ptr = untag_ptr(o);
15558 CHECK_ACCESS(o_ptr);
15559 LDKUtxoLookup o_conv = *(LDKUtxoLookup*)(o_ptr);
15560 if (o_conv.free == LDKUtxoLookup_JCalls_free) {
15561 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
15562 LDKUtxoLookup_JCalls_cloned(&o_conv);
15564 LDKCOption_UtxoLookupZ *ret_copy = MALLOC(sizeof(LDKCOption_UtxoLookupZ), "LDKCOption_UtxoLookupZ");
15565 *ret_copy = COption_UtxoLookupZ_some(o_conv);
15566 uint64_t ret_ref = tag_ptr(ret_copy, true);
15570 uint64_t __attribute__((export_name("TS_COption_UtxoLookupZ_none"))) TS_COption_UtxoLookupZ_none() {
15571 LDKCOption_UtxoLookupZ *ret_copy = MALLOC(sizeof(LDKCOption_UtxoLookupZ), "LDKCOption_UtxoLookupZ");
15572 *ret_copy = COption_UtxoLookupZ_none();
15573 uint64_t ret_ref = tag_ptr(ret_copy, true);
15577 void __attribute__((export_name("TS_COption_UtxoLookupZ_free"))) TS_COption_UtxoLookupZ_free(uint64_t _res) {
15578 if (!ptr_is_owned(_res)) return;
15579 void* _res_ptr = untag_ptr(_res);
15580 CHECK_ACCESS(_res_ptr);
15581 LDKCOption_UtxoLookupZ _res_conv = *(LDKCOption_UtxoLookupZ*)(_res_ptr);
15582 FREE(untag_ptr(_res));
15583 COption_UtxoLookupZ_free(_res_conv);
15586 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_ok"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
15587 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15588 *ret_conv = CResult_boolLightningErrorZ_ok(o);
15589 return tag_ptr(ret_conv, true);
15592 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_err"))) TS_CResult_boolLightningErrorZ_err(uint64_t e) {
15593 LDKLightningError e_conv;
15594 e_conv.inner = untag_ptr(e);
15595 e_conv.is_owned = ptr_is_owned(e);
15596 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15597 e_conv = LightningError_clone(&e_conv);
15598 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15599 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
15600 return tag_ptr(ret_conv, true);
15603 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_is_ok"))) TS_CResult_boolLightningErrorZ_is_ok(uint64_t o) {
15604 LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(o);
15605 jboolean ret_conv = CResult_boolLightningErrorZ_is_ok(o_conv);
15609 void __attribute__((export_name("TS_CResult_boolLightningErrorZ_free"))) TS_CResult_boolLightningErrorZ_free(uint64_t _res) {
15610 if (!ptr_is_owned(_res)) return;
15611 void* _res_ptr = untag_ptr(_res);
15612 CHECK_ACCESS(_res_ptr);
15613 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(_res_ptr);
15614 FREE(untag_ptr(_res));
15615 CResult_boolLightningErrorZ_free(_res_conv);
15618 static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
15619 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15620 *ret_conv = CResult_boolLightningErrorZ_clone(arg);
15621 return tag_ptr(ret_conv, true);
15623 int64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone_ptr"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint64_t arg) {
15624 LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(arg);
15625 int64_t ret_conv = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
15629 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone"))) TS_CResult_boolLightningErrorZ_clone(uint64_t orig) {
15630 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(orig);
15631 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
15632 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
15633 return tag_ptr(ret_conv, true);
15636 static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
15637 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
15638 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
15639 return tag_ptr(ret_conv, true);
15641 int64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint64_t arg) {
15642 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(arg);
15643 int64_t ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
15647 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint64_t orig) {
15648 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(orig);
15649 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
15650 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
15651 return tag_ptr(ret_conv, true);
15654 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint64_t a, uint64_t b, uint64_t c) {
15655 LDKChannelAnnouncement a_conv;
15656 a_conv.inner = untag_ptr(a);
15657 a_conv.is_owned = ptr_is_owned(a);
15658 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
15659 a_conv = ChannelAnnouncement_clone(&a_conv);
15660 LDKChannelUpdate b_conv;
15661 b_conv.inner = untag_ptr(b);
15662 b_conv.is_owned = ptr_is_owned(b);
15663 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
15664 b_conv = ChannelUpdate_clone(&b_conv);
15665 LDKChannelUpdate c_conv;
15666 c_conv.inner = untag_ptr(c);
15667 c_conv.is_owned = ptr_is_owned(c);
15668 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
15669 c_conv = ChannelUpdate_clone(&c_conv);
15670 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
15671 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
15672 return tag_ptr(ret_conv, true);
15675 void __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint64_t _res) {
15676 if (!ptr_is_owned(_res)) return;
15677 void* _res_ptr = untag_ptr(_res);
15678 CHECK_ACCESS(_res_ptr);
15679 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_ptr);
15680 FREE(untag_ptr(_res));
15681 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
15684 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(uint64_t o) {
15685 void* o_ptr = untag_ptr(o);
15686 CHECK_ACCESS(o_ptr);
15687 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(o_ptr);
15688 o_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(o));
15689 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15690 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o_conv);
15691 uint64_t ret_ref = tag_ptr(ret_copy, true);
15695 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none() {
15696 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15697 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
15698 uint64_t ret_ref = tag_ptr(ret_copy, true);
15702 void __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint64_t _res) {
15703 if (!ptr_is_owned(_res)) return;
15704 void* _res_ptr = untag_ptr(_res);
15705 CHECK_ACCESS(_res_ptr);
15706 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(_res_ptr);
15707 FREE(untag_ptr(_res));
15708 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_conv);
15711 static inline uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg) {
15712 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15713 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(arg);
15714 uint64_t ret_ref = tag_ptr(ret_copy, true);
15717 int64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(uint64_t arg) {
15718 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* arg_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(arg);
15719 int64_t ret_conv = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg_conv);
15723 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(uint64_t orig) {
15724 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* orig_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(orig);
15725 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
15726 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig_conv);
15727 uint64_t ret_ref = tag_ptr(ret_copy, true);
15731 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_ok"))) TS_CResult_NoneLightningErrorZ_ok() {
15732 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15733 *ret_conv = CResult_NoneLightningErrorZ_ok();
15734 return tag_ptr(ret_conv, true);
15737 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_err"))) TS_CResult_NoneLightningErrorZ_err(uint64_t e) {
15738 LDKLightningError e_conv;
15739 e_conv.inner = untag_ptr(e);
15740 e_conv.is_owned = ptr_is_owned(e);
15741 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15742 e_conv = LightningError_clone(&e_conv);
15743 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15744 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
15745 return tag_ptr(ret_conv, true);
15748 jboolean __attribute__((export_name("TS_CResult_NoneLightningErrorZ_is_ok"))) TS_CResult_NoneLightningErrorZ_is_ok(uint64_t o) {
15749 LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(o);
15750 jboolean ret_conv = CResult_NoneLightningErrorZ_is_ok(o_conv);
15754 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_free"))) TS_CResult_NoneLightningErrorZ_free(uint64_t _res) {
15755 if (!ptr_is_owned(_res)) return;
15756 void* _res_ptr = untag_ptr(_res);
15757 CHECK_ACCESS(_res_ptr);
15758 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(_res_ptr);
15759 FREE(untag_ptr(_res));
15760 CResult_NoneLightningErrorZ_free(_res_conv);
15763 static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
15764 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15765 *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
15766 return tag_ptr(ret_conv, true);
15768 int64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone_ptr"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint64_t arg) {
15769 LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(arg);
15770 int64_t ret_conv = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
15774 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone"))) TS_CResult_NoneLightningErrorZ_clone(uint64_t orig) {
15775 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(orig);
15776 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
15777 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
15778 return tag_ptr(ret_conv, true);
15781 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(uint64_t o) {
15782 LDKChannelUpdateInfo o_conv;
15783 o_conv.inner = untag_ptr(o);
15784 o_conv.is_owned = ptr_is_owned(o);
15785 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15786 o_conv = ChannelUpdateInfo_clone(&o_conv);
15787 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15788 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_ok(o_conv);
15789 return tag_ptr(ret_conv, true);
15792 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(uint64_t e) {
15793 void* e_ptr = untag_ptr(e);
15794 CHECK_ACCESS(e_ptr);
15795 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15796 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15797 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15798 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_err(e_conv);
15799 return tag_ptr(ret_conv, true);
15802 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(uint64_t o) {
15803 LDKCResult_ChannelUpdateInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(o);
15804 jboolean ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o_conv);
15808 void __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_free"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(uint64_t _res) {
15809 if (!ptr_is_owned(_res)) return;
15810 void* _res_ptr = untag_ptr(_res);
15811 CHECK_ACCESS(_res_ptr);
15812 LDKCResult_ChannelUpdateInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(_res_ptr);
15813 FREE(untag_ptr(_res));
15814 CResult_ChannelUpdateInfoDecodeErrorZ_free(_res_conv);
15817 static inline uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg) {
15818 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15819 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(arg);
15820 return tag_ptr(ret_conv, true);
15822 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15823 LDKCResult_ChannelUpdateInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(arg);
15824 int64_t ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg_conv);
15828 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(uint64_t orig) {
15829 LDKCResult_ChannelUpdateInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(orig);
15830 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
15831 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig_conv);
15832 return tag_ptr(ret_conv, true);
15835 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint64_t o) {
15836 LDKChannelInfo o_conv;
15837 o_conv.inner = untag_ptr(o);
15838 o_conv.is_owned = ptr_is_owned(o);
15839 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15840 o_conv = ChannelInfo_clone(&o_conv);
15841 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15842 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
15843 return tag_ptr(ret_conv, true);
15846 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_err"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint64_t e) {
15847 void* e_ptr = untag_ptr(e);
15848 CHECK_ACCESS(e_ptr);
15849 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15850 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15851 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15852 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
15853 return tag_ptr(ret_conv, true);
15856 jboolean __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint64_t o) {
15857 LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(o);
15858 jboolean ret_conv = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
15862 void __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_free"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint64_t _res) {
15863 if (!ptr_is_owned(_res)) return;
15864 void* _res_ptr = untag_ptr(_res);
15865 CHECK_ACCESS(_res_ptr);
15866 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(_res_ptr);
15867 FREE(untag_ptr(_res));
15868 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
15871 static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
15872 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15873 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
15874 return tag_ptr(ret_conv, true);
15876 int64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15877 LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(arg);
15878 int64_t ret_conv = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
15882 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint64_t orig) {
15883 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(orig);
15884 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
15885 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
15886 return tag_ptr(ret_conv, true);
15889 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint64_t o) {
15890 LDKRoutingFees o_conv;
15891 o_conv.inner = untag_ptr(o);
15892 o_conv.is_owned = ptr_is_owned(o);
15893 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15894 o_conv = RoutingFees_clone(&o_conv);
15895 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15896 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
15897 return tag_ptr(ret_conv, true);
15900 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_err"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint64_t e) {
15901 void* e_ptr = untag_ptr(e);
15902 CHECK_ACCESS(e_ptr);
15903 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15904 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15905 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15906 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
15907 return tag_ptr(ret_conv, true);
15910 jboolean __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_is_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint64_t o) {
15911 LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(o);
15912 jboolean ret_conv = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
15916 void __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_free"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint64_t _res) {
15917 if (!ptr_is_owned(_res)) return;
15918 void* _res_ptr = untag_ptr(_res);
15919 CHECK_ACCESS(_res_ptr);
15920 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(_res_ptr);
15921 FREE(untag_ptr(_res));
15922 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
15925 static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
15926 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15927 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
15928 return tag_ptr(ret_conv, true);
15930 int64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint64_t arg) {
15931 LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(arg);
15932 int64_t ret_conv = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
15936 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint64_t orig) {
15937 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(orig);
15938 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
15939 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
15940 return tag_ptr(ret_conv, true);
15943 void __attribute__((export_name("TS_CVec_NetAddressZ_free"))) TS_CVec_NetAddressZ_free(uint64_tArray _res) {
15944 LDKCVec_NetAddressZ _res_constr;
15945 _res_constr.datalen = _res->arr_len;
15946 if (_res_constr.datalen > 0)
15947 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
15949 _res_constr.data = NULL;
15950 uint64_t* _res_vals = _res->elems;
15951 for (size_t m = 0; m < _res_constr.datalen; m++) {
15952 uint64_t _res_conv_12 = _res_vals[m];
15953 void* _res_conv_12_ptr = untag_ptr(_res_conv_12);
15954 CHECK_ACCESS(_res_conv_12_ptr);
15955 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(_res_conv_12_ptr);
15956 FREE(untag_ptr(_res_conv_12));
15957 _res_constr.data[m] = _res_conv_12_conv;
15960 CVec_NetAddressZ_free(_res_constr);
15963 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint64_t o) {
15964 LDKNodeAnnouncementInfo o_conv;
15965 o_conv.inner = untag_ptr(o);
15966 o_conv.is_owned = ptr_is_owned(o);
15967 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15968 o_conv = NodeAnnouncementInfo_clone(&o_conv);
15969 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15970 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
15971 return tag_ptr(ret_conv, true);
15974 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint64_t e) {
15975 void* e_ptr = untag_ptr(e);
15976 CHECK_ACCESS(e_ptr);
15977 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15978 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15979 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
15980 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
15981 return tag_ptr(ret_conv, true);
15984 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint64_t o) {
15985 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(o);
15986 jboolean ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
15990 void __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint64_t _res) {
15991 if (!ptr_is_owned(_res)) return;
15992 void* _res_ptr = untag_ptr(_res);
15993 CHECK_ACCESS(_res_ptr);
15994 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(_res_ptr);
15995 FREE(untag_ptr(_res));
15996 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
15999 static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
16000 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
16001 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
16002 return tag_ptr(ret_conv, true);
16004 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
16005 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(arg);
16006 int64_t ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
16010 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint64_t orig) {
16011 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(orig);
16012 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
16013 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
16014 return tag_ptr(ret_conv, true);
16017 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_ok"))) TS_CResult_NodeAliasDecodeErrorZ_ok(uint64_t o) {
16018 LDKNodeAlias o_conv;
16019 o_conv.inner = untag_ptr(o);
16020 o_conv.is_owned = ptr_is_owned(o);
16021 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16022 o_conv = NodeAlias_clone(&o_conv);
16023 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16024 *ret_conv = CResult_NodeAliasDecodeErrorZ_ok(o_conv);
16025 return tag_ptr(ret_conv, true);
16028 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_err"))) TS_CResult_NodeAliasDecodeErrorZ_err(uint64_t e) {
16029 void* e_ptr = untag_ptr(e);
16030 CHECK_ACCESS(e_ptr);
16031 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16032 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16033 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16034 *ret_conv = CResult_NodeAliasDecodeErrorZ_err(e_conv);
16035 return tag_ptr(ret_conv, true);
16038 jboolean __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_is_ok"))) TS_CResult_NodeAliasDecodeErrorZ_is_ok(uint64_t o) {
16039 LDKCResult_NodeAliasDecodeErrorZ* o_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(o);
16040 jboolean ret_conv = CResult_NodeAliasDecodeErrorZ_is_ok(o_conv);
16044 void __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_free"))) TS_CResult_NodeAliasDecodeErrorZ_free(uint64_t _res) {
16045 if (!ptr_is_owned(_res)) return;
16046 void* _res_ptr = untag_ptr(_res);
16047 CHECK_ACCESS(_res_ptr);
16048 LDKCResult_NodeAliasDecodeErrorZ _res_conv = *(LDKCResult_NodeAliasDecodeErrorZ*)(_res_ptr);
16049 FREE(untag_ptr(_res));
16050 CResult_NodeAliasDecodeErrorZ_free(_res_conv);
16053 static inline uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg) {
16054 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16055 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(arg);
16056 return tag_ptr(ret_conv, true);
16058 int64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(uint64_t arg) {
16059 LDKCResult_NodeAliasDecodeErrorZ* arg_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(arg);
16060 int64_t ret_conv = CResult_NodeAliasDecodeErrorZ_clone_ptr(arg_conv);
16064 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone"))) TS_CResult_NodeAliasDecodeErrorZ_clone(uint64_t orig) {
16065 LDKCResult_NodeAliasDecodeErrorZ* orig_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(orig);
16066 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
16067 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(orig_conv);
16068 return tag_ptr(ret_conv, true);
16071 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_ok"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint64_t o) {
16072 LDKNodeInfo o_conv;
16073 o_conv.inner = untag_ptr(o);
16074 o_conv.is_owned = ptr_is_owned(o);
16075 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16076 o_conv = NodeInfo_clone(&o_conv);
16077 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16078 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
16079 return tag_ptr(ret_conv, true);
16082 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_err"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint64_t e) {
16083 void* e_ptr = untag_ptr(e);
16084 CHECK_ACCESS(e_ptr);
16085 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16086 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16087 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16088 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
16089 return tag_ptr(ret_conv, true);
16092 jboolean __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint64_t o) {
16093 LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(o);
16094 jboolean ret_conv = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
16098 void __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_free"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint64_t _res) {
16099 if (!ptr_is_owned(_res)) return;
16100 void* _res_ptr = untag_ptr(_res);
16101 CHECK_ACCESS(_res_ptr);
16102 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(_res_ptr);
16103 FREE(untag_ptr(_res));
16104 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
16107 static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
16108 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16109 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
16110 return tag_ptr(ret_conv, true);
16112 int64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
16113 LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(arg);
16114 int64_t ret_conv = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
16118 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint64_t orig) {
16119 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(orig);
16120 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
16121 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
16122 return tag_ptr(ret_conv, true);
16125 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint64_t o) {
16126 LDKNetworkGraph o_conv;
16127 o_conv.inner = untag_ptr(o);
16128 o_conv.is_owned = ptr_is_owned(o);
16129 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16130 // WARNING: we need a move here but no clone is available for LDKNetworkGraph
16132 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
16133 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
16134 return tag_ptr(ret_conv, true);
16137 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_err"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint64_t e) {
16138 void* e_ptr = untag_ptr(e);
16139 CHECK_ACCESS(e_ptr);
16140 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16141 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16142 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
16143 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
16144 return tag_ptr(ret_conv, true);
16147 jboolean __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_is_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint64_t o) {
16148 LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(o);
16149 jboolean ret_conv = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
16153 void __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_free"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint64_t _res) {
16154 if (!ptr_is_owned(_res)) return;
16155 void* _res_ptr = untag_ptr(_res);
16156 CHECK_ACCESS(_res_ptr);
16157 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(_res_ptr);
16158 FREE(untag_ptr(_res));
16159 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
16162 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_some"))) TS_COption_CVec_NetAddressZZ_some(uint64_tArray o) {
16163 LDKCVec_NetAddressZ o_constr;
16164 o_constr.datalen = o->arr_len;
16165 if (o_constr.datalen > 0)
16166 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
16168 o_constr.data = NULL;
16169 uint64_t* o_vals = o->elems;
16170 for (size_t m = 0; m < o_constr.datalen; m++) {
16171 uint64_t o_conv_12 = o_vals[m];
16172 void* o_conv_12_ptr = untag_ptr(o_conv_12);
16173 CHECK_ACCESS(o_conv_12_ptr);
16174 LDKNetAddress o_conv_12_conv = *(LDKNetAddress*)(o_conv_12_ptr);
16175 o_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o_conv_12));
16176 o_constr.data[m] = o_conv_12_conv;
16179 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16180 *ret_copy = COption_CVec_NetAddressZZ_some(o_constr);
16181 uint64_t ret_ref = tag_ptr(ret_copy, true);
16185 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_none"))) TS_COption_CVec_NetAddressZZ_none() {
16186 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16187 *ret_copy = COption_CVec_NetAddressZZ_none();
16188 uint64_t ret_ref = tag_ptr(ret_copy, true);
16192 void __attribute__((export_name("TS_COption_CVec_NetAddressZZ_free"))) TS_COption_CVec_NetAddressZZ_free(uint64_t _res) {
16193 if (!ptr_is_owned(_res)) return;
16194 void* _res_ptr = untag_ptr(_res);
16195 CHECK_ACCESS(_res_ptr);
16196 LDKCOption_CVec_NetAddressZZ _res_conv = *(LDKCOption_CVec_NetAddressZZ*)(_res_ptr);
16197 FREE(untag_ptr(_res));
16198 COption_CVec_NetAddressZZ_free(_res_conv);
16201 static inline uint64_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
16202 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16203 *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
16204 uint64_t ret_ref = tag_ptr(ret_copy, true);
16207 int64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone_ptr"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint64_t arg) {
16208 LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(arg);
16209 int64_t ret_conv = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
16213 uint64_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone"))) TS_COption_CVec_NetAddressZZ_clone(uint64_t orig) {
16214 LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)untag_ptr(orig);
16215 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
16216 *ret_copy = COption_CVec_NetAddressZZ_clone(orig_conv);
16217 uint64_t ret_ref = tag_ptr(ret_copy, true);
16221 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
16222 LDKDelayedPaymentOutputDescriptor o_conv;
16223 o_conv.inner = untag_ptr(o);
16224 o_conv.is_owned = ptr_is_owned(o);
16225 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16226 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
16227 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16228 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
16229 return tag_ptr(ret_conv, true);
16232 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
16233 void* e_ptr = untag_ptr(e);
16234 CHECK_ACCESS(e_ptr);
16235 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16236 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16237 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16238 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
16239 return tag_ptr(ret_conv, true);
16242 jboolean __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
16243 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
16244 jboolean ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
16248 void __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
16249 if (!ptr_is_owned(_res)) return;
16250 void* _res_ptr = untag_ptr(_res);
16251 CHECK_ACCESS(_res_ptr);
16252 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
16253 FREE(untag_ptr(_res));
16254 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
16257 static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16258 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16259 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
16260 return tag_ptr(ret_conv, true);
16262 int64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16263 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16264 int64_t ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16268 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16269 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16270 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
16271 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
16272 return tag_ptr(ret_conv, true);
16275 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
16276 LDKStaticPaymentOutputDescriptor o_conv;
16277 o_conv.inner = untag_ptr(o);
16278 o_conv.is_owned = ptr_is_owned(o);
16279 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16280 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
16281 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16282 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
16283 return tag_ptr(ret_conv, true);
16286 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
16287 void* e_ptr = untag_ptr(e);
16288 CHECK_ACCESS(e_ptr);
16289 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16290 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16291 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16292 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
16293 return tag_ptr(ret_conv, true);
16296 jboolean __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
16297 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
16298 jboolean ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
16302 void __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
16303 if (!ptr_is_owned(_res)) return;
16304 void* _res_ptr = untag_ptr(_res);
16305 CHECK_ACCESS(_res_ptr);
16306 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
16307 FREE(untag_ptr(_res));
16308 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
16311 static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16312 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16313 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
16314 return tag_ptr(ret_conv, true);
16316 int64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16317 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16318 int64_t ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16322 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16323 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16324 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
16325 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
16326 return tag_ptr(ret_conv, true);
16329 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
16330 void* o_ptr = untag_ptr(o);
16331 CHECK_ACCESS(o_ptr);
16332 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(o_ptr);
16333 o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(o));
16334 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16335 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
16336 return tag_ptr(ret_conv, true);
16339 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(uint64_t e) {
16340 void* e_ptr = untag_ptr(e);
16341 CHECK_ACCESS(e_ptr);
16342 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16343 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16344 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16345 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
16346 return tag_ptr(ret_conv, true);
16349 jboolean __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
16350 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(o);
16351 jboolean ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
16355 void __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
16356 if (!ptr_is_owned(_res)) return;
16357 void* _res_ptr = untag_ptr(_res);
16358 CHECK_ACCESS(_res_ptr);
16359 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(_res_ptr);
16360 FREE(untag_ptr(_res));
16361 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
16364 static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16365 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16366 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
16367 return tag_ptr(ret_conv, true);
16369 int64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16370 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16371 int64_t ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16375 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16376 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16377 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16378 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
16379 return tag_ptr(ret_conv, true);
16382 void __attribute__((export_name("TS_CVec_PaymentPreimageZ_free"))) TS_CVec_PaymentPreimageZ_free(ptrArray _res) {
16383 LDKCVec_PaymentPreimageZ _res_constr;
16384 _res_constr.datalen = _res->arr_len;
16385 if (_res_constr.datalen > 0)
16386 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
16388 _res_constr.data = NULL;
16389 int8_tArray* _res_vals = (void*) _res->elems;
16390 for (size_t m = 0; m < _res_constr.datalen; m++) {
16391 int8_tArray _res_conv_12 = _res_vals[m];
16392 LDKThirtyTwoBytes _res_conv_12_ref;
16393 CHECK(_res_conv_12->arr_len == 32);
16394 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
16395 _res_constr.data[m] = _res_conv_12_ref;
16398 CVec_PaymentPreimageZ_free(_res_constr);
16401 static inline uint64_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
16402 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
16403 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
16404 return tag_ptr(ret_conv, true);
16406 int64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint64_t arg) {
16407 LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(arg);
16408 int64_t ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
16412 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint64_t orig) {
16413 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(orig);
16414 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
16415 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
16416 return tag_ptr(ret_conv, true);
16419 uint64_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_new"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
16420 LDKSignature a_ref;
16421 CHECK(a->arr_len == 64);
16422 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
16423 LDKCVec_SignatureZ b_constr;
16424 b_constr.datalen = b->arr_len;
16425 if (b_constr.datalen > 0)
16426 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
16428 b_constr.data = NULL;
16429 int8_tArray* b_vals = (void*) b->elems;
16430 for (size_t m = 0; m < b_constr.datalen; m++) {
16431 int8_tArray b_conv_12 = b_vals[m];
16432 LDKSignature b_conv_12_ref;
16433 CHECK(b_conv_12->arr_len == 64);
16434 memcpy(b_conv_12_ref.compact_form, b_conv_12->elems, 64); FREE(b_conv_12);
16435 b_constr.data[m] = b_conv_12_ref;
16438 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
16439 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
16440 return tag_ptr(ret_conv, true);
16443 void __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_free"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint64_t _res) {
16444 if (!ptr_is_owned(_res)) return;
16445 void* _res_ptr = untag_ptr(_res);
16446 CHECK_ACCESS(_res_ptr);
16447 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(_res_ptr);
16448 FREE(untag_ptr(_res));
16449 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
16452 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint64_t o) {
16453 void* o_ptr = untag_ptr(o);
16454 CHECK_ACCESS(o_ptr);
16455 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(o_ptr);
16456 o_conv = C2Tuple_SignatureCVec_SignatureZZ_clone((LDKC2Tuple_SignatureCVec_SignatureZZ*)untag_ptr(o));
16457 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16458 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
16459 return tag_ptr(ret_conv, true);
16462 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() {
16463 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16464 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
16465 return tag_ptr(ret_conv, true);
16468 jboolean __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint64_t o) {
16469 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(o);
16470 jboolean ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
16474 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint64_t _res) {
16475 if (!ptr_is_owned(_res)) return;
16476 void* _res_ptr = untag_ptr(_res);
16477 CHECK_ACCESS(_res_ptr);
16478 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(_res_ptr);
16479 FREE(untag_ptr(_res));
16480 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
16483 static inline uint64_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
16484 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16485 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
16486 return tag_ptr(ret_conv, true);
16488 int64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint64_t arg) {
16489 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(arg);
16490 int64_t ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
16494 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint64_t orig) {
16495 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)untag_ptr(orig);
16496 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
16497 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
16498 return tag_ptr(ret_conv, true);
16501 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_ok"))) TS_CResult_SignatureNoneZ_ok(int8_tArray o) {
16502 LDKSignature o_ref;
16503 CHECK(o->arr_len == 64);
16504 memcpy(o_ref.compact_form, o->elems, 64); FREE(o);
16505 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16506 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
16507 return tag_ptr(ret_conv, true);
16510 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_err"))) TS_CResult_SignatureNoneZ_err() {
16511 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16512 *ret_conv = CResult_SignatureNoneZ_err();
16513 return tag_ptr(ret_conv, true);
16516 jboolean __attribute__((export_name("TS_CResult_SignatureNoneZ_is_ok"))) TS_CResult_SignatureNoneZ_is_ok(uint64_t o) {
16517 LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(o);
16518 jboolean ret_conv = CResult_SignatureNoneZ_is_ok(o_conv);
16522 void __attribute__((export_name("TS_CResult_SignatureNoneZ_free"))) TS_CResult_SignatureNoneZ_free(uint64_t _res) {
16523 if (!ptr_is_owned(_res)) return;
16524 void* _res_ptr = untag_ptr(_res);
16525 CHECK_ACCESS(_res_ptr);
16526 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(_res_ptr);
16527 FREE(untag_ptr(_res));
16528 CResult_SignatureNoneZ_free(_res_conv);
16531 static inline uint64_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
16532 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16533 *ret_conv = CResult_SignatureNoneZ_clone(arg);
16534 return tag_ptr(ret_conv, true);
16536 int64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone_ptr"))) TS_CResult_SignatureNoneZ_clone_ptr(uint64_t arg) {
16537 LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(arg);
16538 int64_t ret_conv = CResult_SignatureNoneZ_clone_ptr(arg_conv);
16542 uint64_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone"))) TS_CResult_SignatureNoneZ_clone(uint64_t orig) {
16543 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)untag_ptr(orig);
16544 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
16545 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
16546 return tag_ptr(ret_conv, true);
16549 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_ok"))) TS_CResult_PublicKeyNoneZ_ok(int8_tArray o) {
16550 LDKPublicKey o_ref;
16551 CHECK(o->arr_len == 33);
16552 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
16553 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16554 *ret_conv = CResult_PublicKeyNoneZ_ok(o_ref);
16555 return tag_ptr(ret_conv, true);
16558 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_err"))) TS_CResult_PublicKeyNoneZ_err() {
16559 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16560 *ret_conv = CResult_PublicKeyNoneZ_err();
16561 return tag_ptr(ret_conv, true);
16564 jboolean __attribute__((export_name("TS_CResult_PublicKeyNoneZ_is_ok"))) TS_CResult_PublicKeyNoneZ_is_ok(uint64_t o) {
16565 LDKCResult_PublicKeyNoneZ* o_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(o);
16566 jboolean ret_conv = CResult_PublicKeyNoneZ_is_ok(o_conv);
16570 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_free"))) TS_CResult_PublicKeyNoneZ_free(uint64_t _res) {
16571 if (!ptr_is_owned(_res)) return;
16572 void* _res_ptr = untag_ptr(_res);
16573 CHECK_ACCESS(_res_ptr);
16574 LDKCResult_PublicKeyNoneZ _res_conv = *(LDKCResult_PublicKeyNoneZ*)(_res_ptr);
16575 FREE(untag_ptr(_res));
16576 CResult_PublicKeyNoneZ_free(_res_conv);
16579 static inline uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg) {
16580 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16581 *ret_conv = CResult_PublicKeyNoneZ_clone(arg);
16582 return tag_ptr(ret_conv, true);
16584 int64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone_ptr"))) TS_CResult_PublicKeyNoneZ_clone_ptr(uint64_t arg) {
16585 LDKCResult_PublicKeyNoneZ* arg_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(arg);
16586 int64_t ret_conv = CResult_PublicKeyNoneZ_clone_ptr(arg_conv);
16590 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone"))) TS_CResult_PublicKeyNoneZ_clone(uint64_t orig) {
16591 LDKCResult_PublicKeyNoneZ* orig_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(orig);
16592 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16593 *ret_conv = CResult_PublicKeyNoneZ_clone(orig_conv);
16594 return tag_ptr(ret_conv, true);
16597 uint64_t __attribute__((export_name("TS_COption_ScalarZ_some"))) TS_COption_ScalarZ_some(uint64_t o) {
16598 void* o_ptr = untag_ptr(o);
16599 CHECK_ACCESS(o_ptr);
16600 LDKBigEndianScalar o_conv = *(LDKBigEndianScalar*)(o_ptr);
16601 // WARNING: we may need a move here but no clone is available for LDKBigEndianScalar
16602 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16603 *ret_copy = COption_ScalarZ_some(o_conv);
16604 uint64_t ret_ref = tag_ptr(ret_copy, true);
16608 uint64_t __attribute__((export_name("TS_COption_ScalarZ_none"))) TS_COption_ScalarZ_none() {
16609 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16610 *ret_copy = COption_ScalarZ_none();
16611 uint64_t ret_ref = tag_ptr(ret_copy, true);
16615 void __attribute__((export_name("TS_COption_ScalarZ_free"))) TS_COption_ScalarZ_free(uint64_t _res) {
16616 if (!ptr_is_owned(_res)) return;
16617 void* _res_ptr = untag_ptr(_res);
16618 CHECK_ACCESS(_res_ptr);
16619 LDKCOption_ScalarZ _res_conv = *(LDKCOption_ScalarZ*)(_res_ptr);
16620 FREE(untag_ptr(_res));
16621 COption_ScalarZ_free(_res_conv);
16624 static inline uint64_t COption_ScalarZ_clone_ptr(LDKCOption_ScalarZ *NONNULL_PTR arg) {
16625 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16626 *ret_copy = COption_ScalarZ_clone(arg);
16627 uint64_t ret_ref = tag_ptr(ret_copy, true);
16630 int64_t __attribute__((export_name("TS_COption_ScalarZ_clone_ptr"))) TS_COption_ScalarZ_clone_ptr(uint64_t arg) {
16631 LDKCOption_ScalarZ* arg_conv = (LDKCOption_ScalarZ*)untag_ptr(arg);
16632 int64_t ret_conv = COption_ScalarZ_clone_ptr(arg_conv);
16636 uint64_t __attribute__((export_name("TS_COption_ScalarZ_clone"))) TS_COption_ScalarZ_clone(uint64_t orig) {
16637 LDKCOption_ScalarZ* orig_conv = (LDKCOption_ScalarZ*)untag_ptr(orig);
16638 LDKCOption_ScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_ScalarZ), "LDKCOption_ScalarZ");
16639 *ret_copy = COption_ScalarZ_clone(orig_conv);
16640 uint64_t ret_ref = tag_ptr(ret_copy, true);
16644 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_ok"))) TS_CResult_SharedSecretNoneZ_ok(int8_tArray o) {
16645 LDKThirtyTwoBytes o_ref;
16646 CHECK(o->arr_len == 32);
16647 memcpy(o_ref.data, o->elems, 32); FREE(o);
16648 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16649 *ret_conv = CResult_SharedSecretNoneZ_ok(o_ref);
16650 return tag_ptr(ret_conv, true);
16653 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_err"))) TS_CResult_SharedSecretNoneZ_err() {
16654 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16655 *ret_conv = CResult_SharedSecretNoneZ_err();
16656 return tag_ptr(ret_conv, true);
16659 jboolean __attribute__((export_name("TS_CResult_SharedSecretNoneZ_is_ok"))) TS_CResult_SharedSecretNoneZ_is_ok(uint64_t o) {
16660 LDKCResult_SharedSecretNoneZ* o_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(o);
16661 jboolean ret_conv = CResult_SharedSecretNoneZ_is_ok(o_conv);
16665 void __attribute__((export_name("TS_CResult_SharedSecretNoneZ_free"))) TS_CResult_SharedSecretNoneZ_free(uint64_t _res) {
16666 if (!ptr_is_owned(_res)) return;
16667 void* _res_ptr = untag_ptr(_res);
16668 CHECK_ACCESS(_res_ptr);
16669 LDKCResult_SharedSecretNoneZ _res_conv = *(LDKCResult_SharedSecretNoneZ*)(_res_ptr);
16670 FREE(untag_ptr(_res));
16671 CResult_SharedSecretNoneZ_free(_res_conv);
16674 static inline uint64_t CResult_SharedSecretNoneZ_clone_ptr(LDKCResult_SharedSecretNoneZ *NONNULL_PTR arg) {
16675 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16676 *ret_conv = CResult_SharedSecretNoneZ_clone(arg);
16677 return tag_ptr(ret_conv, true);
16679 int64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_clone_ptr"))) TS_CResult_SharedSecretNoneZ_clone_ptr(uint64_t arg) {
16680 LDKCResult_SharedSecretNoneZ* arg_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(arg);
16681 int64_t ret_conv = CResult_SharedSecretNoneZ_clone_ptr(arg_conv);
16685 uint64_t __attribute__((export_name("TS_CResult_SharedSecretNoneZ_clone"))) TS_CResult_SharedSecretNoneZ_clone(uint64_t orig) {
16686 LDKCResult_SharedSecretNoneZ* orig_conv = (LDKCResult_SharedSecretNoneZ*)untag_ptr(orig);
16687 LDKCResult_SharedSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SharedSecretNoneZ), "LDKCResult_SharedSecretNoneZ");
16688 *ret_conv = CResult_SharedSecretNoneZ_clone(orig_conv);
16689 return tag_ptr(ret_conv, true);
16692 void __attribute__((export_name("TS_CVec_U5Z_free"))) TS_CVec_U5Z_free(ptrArray _res) {
16693 LDKCVec_U5Z _res_constr;
16694 _res_constr.datalen = _res->arr_len;
16695 if (_res_constr.datalen > 0)
16696 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
16698 _res_constr.data = NULL;
16699 int8_t* _res_vals = (void*) _res->elems;
16700 for (size_t h = 0; h < _res_constr.datalen; h++) {
16701 int8_t _res_conv_7 = _res_vals[h];
16703 _res_constr.data[h] = (LDKU5){ ._0 = _res_conv_7 };
16706 CVec_U5Z_free(_res_constr);
16709 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_ok"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray o) {
16710 LDKRecoverableSignature o_ref;
16711 CHECK(o->arr_len == 68);
16712 memcpy(o_ref.serialized_form, o->elems, 68); FREE(o);
16713 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16714 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(o_ref);
16715 return tag_ptr(ret_conv, true);
16718 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_err"))) TS_CResult_RecoverableSignatureNoneZ_err() {
16719 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16720 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
16721 return tag_ptr(ret_conv, true);
16724 jboolean __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_is_ok"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint64_t o) {
16725 LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(o);
16726 jboolean ret_conv = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
16730 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_free"))) TS_CResult_RecoverableSignatureNoneZ_free(uint64_t _res) {
16731 if (!ptr_is_owned(_res)) return;
16732 void* _res_ptr = untag_ptr(_res);
16733 CHECK_ACCESS(_res_ptr);
16734 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(_res_ptr);
16735 FREE(untag_ptr(_res));
16736 CResult_RecoverableSignatureNoneZ_free(_res_conv);
16739 static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
16740 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16741 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
16742 return tag_ptr(ret_conv, true);
16744 int64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone_ptr"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint64_t arg) {
16745 LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(arg);
16746 int64_t ret_conv = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
16750 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint64_t orig) {
16751 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(orig);
16752 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16753 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
16754 return tag_ptr(ret_conv, true);
16757 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(uint64_t o) {
16758 void* o_ptr = untag_ptr(o);
16759 CHECK_ACCESS(o_ptr);
16760 LDKWriteableEcdsaChannelSigner o_conv = *(LDKWriteableEcdsaChannelSigner*)(o_ptr);
16761 if (o_conv.free == LDKWriteableEcdsaChannelSigner_JCalls_free) {
16762 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16763 LDKWriteableEcdsaChannelSigner_JCalls_cloned(&o_conv);
16765 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16766 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o_conv);
16767 return tag_ptr(ret_conv, true);
16770 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(uint64_t e) {
16771 void* e_ptr = untag_ptr(e);
16772 CHECK_ACCESS(e_ptr);
16773 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16774 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16775 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16776 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e_conv);
16777 return tag_ptr(ret_conv, true);
16780 jboolean __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(uint64_t o) {
16781 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* o_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(o);
16782 jboolean ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o_conv);
16786 void __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(uint64_t _res) {
16787 if (!ptr_is_owned(_res)) return;
16788 void* _res_ptr = untag_ptr(_res);
16789 CHECK_ACCESS(_res_ptr);
16790 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res_conv = *(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)(_res_ptr);
16791 FREE(untag_ptr(_res));
16792 CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res_conv);
16795 static inline uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg) {
16796 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16797 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(arg);
16798 return tag_ptr(ret_conv, true);
16800 int64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16801 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* arg_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(arg);
16802 int64_t ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg_conv);
16806 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(uint64_t orig) {
16807 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* orig_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(orig);
16808 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16809 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig_conv);
16810 return tag_ptr(ret_conv, true);
16813 void __attribute__((export_name("TS_CVec_CVec_u8ZZ_free"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
16814 LDKCVec_CVec_u8ZZ _res_constr;
16815 _res_constr.datalen = _res->arr_len;
16816 if (_res_constr.datalen > 0)
16817 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16819 _res_constr.data = NULL;
16820 int8_tArray* _res_vals = (void*) _res->elems;
16821 for (size_t m = 0; m < _res_constr.datalen; m++) {
16822 int8_tArray _res_conv_12 = _res_vals[m];
16823 LDKCVec_u8Z _res_conv_12_ref;
16824 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
16825 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16826 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
16827 _res_constr.data[m] = _res_conv_12_ref;
16830 CVec_CVec_u8ZZ_free(_res_constr);
16833 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
16834 LDKCVec_CVec_u8ZZ o_constr;
16835 o_constr.datalen = o->arr_len;
16836 if (o_constr.datalen > 0)
16837 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16839 o_constr.data = NULL;
16840 int8_tArray* o_vals = (void*) o->elems;
16841 for (size_t m = 0; m < o_constr.datalen; m++) {
16842 int8_tArray o_conv_12 = o_vals[m];
16843 LDKCVec_u8Z o_conv_12_ref;
16844 o_conv_12_ref.datalen = o_conv_12->arr_len;
16845 o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16846 memcpy(o_conv_12_ref.data, o_conv_12->elems, o_conv_12_ref.datalen); FREE(o_conv_12);
16847 o_constr.data[m] = o_conv_12_ref;
16850 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16851 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
16852 return tag_ptr(ret_conv, true);
16855 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
16856 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16857 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
16858 return tag_ptr(ret_conv, true);
16861 jboolean __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint64_t o) {
16862 LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(o);
16863 jboolean ret_conv = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
16867 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_free"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint64_t _res) {
16868 if (!ptr_is_owned(_res)) return;
16869 void* _res_ptr = untag_ptr(_res);
16870 CHECK_ACCESS(_res_ptr);
16871 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(_res_ptr);
16872 FREE(untag_ptr(_res));
16873 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
16876 static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
16877 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16878 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
16879 return tag_ptr(ret_conv, true);
16881 int64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint64_t arg) {
16882 LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(arg);
16883 int64_t ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
16887 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint64_t orig) {
16888 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(orig);
16889 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16890 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
16891 return tag_ptr(ret_conv, true);
16894 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint64_t o) {
16895 LDKInMemorySigner o_conv;
16896 o_conv.inner = untag_ptr(o);
16897 o_conv.is_owned = ptr_is_owned(o);
16898 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16899 o_conv = InMemorySigner_clone(&o_conv);
16900 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16901 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
16902 return tag_ptr(ret_conv, true);
16905 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_err"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint64_t e) {
16906 void* e_ptr = untag_ptr(e);
16907 CHECK_ACCESS(e_ptr);
16908 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16909 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16910 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16911 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
16912 return tag_ptr(ret_conv, true);
16915 jboolean __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_is_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint64_t o) {
16916 LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(o);
16917 jboolean ret_conv = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
16921 void __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_free"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint64_t _res) {
16922 if (!ptr_is_owned(_res)) return;
16923 void* _res_ptr = untag_ptr(_res);
16924 CHECK_ACCESS(_res_ptr);
16925 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(_res_ptr);
16926 FREE(untag_ptr(_res));
16927 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
16930 static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
16931 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16932 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
16933 return tag_ptr(ret_conv, true);
16935 int64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16936 LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(arg);
16937 int64_t ret_conv = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
16941 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint64_t orig) {
16942 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(orig);
16943 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16944 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
16945 return tag_ptr(ret_conv, true);
16948 void __attribute__((export_name("TS_CVec_TxOutZ_free"))) TS_CVec_TxOutZ_free(uint64_tArray _res) {
16949 LDKCVec_TxOutZ _res_constr;
16950 _res_constr.datalen = _res->arr_len;
16951 if (_res_constr.datalen > 0)
16952 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
16954 _res_constr.data = NULL;
16955 uint64_t* _res_vals = _res->elems;
16956 for (size_t h = 0; h < _res_constr.datalen; h++) {
16957 uint64_t _res_conv_7 = _res_vals[h];
16958 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
16959 CHECK_ACCESS(_res_conv_7_ptr);
16960 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(_res_conv_7_ptr);
16961 FREE(untag_ptr(_res_conv_7));
16962 _res_constr.data[h] = _res_conv_7_conv;
16965 CVec_TxOutZ_free(_res_constr);
16968 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_ok"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
16969 LDKTransaction o_ref;
16970 o_ref.datalen = o->arr_len;
16971 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
16972 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
16973 o_ref.data_is_owned = true;
16974 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16975 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
16976 return tag_ptr(ret_conv, true);
16979 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_err"))) TS_CResult_TransactionNoneZ_err() {
16980 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16981 *ret_conv = CResult_TransactionNoneZ_err();
16982 return tag_ptr(ret_conv, true);
16985 jboolean __attribute__((export_name("TS_CResult_TransactionNoneZ_is_ok"))) TS_CResult_TransactionNoneZ_is_ok(uint64_t o) {
16986 LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(o);
16987 jboolean ret_conv = CResult_TransactionNoneZ_is_ok(o_conv);
16991 void __attribute__((export_name("TS_CResult_TransactionNoneZ_free"))) TS_CResult_TransactionNoneZ_free(uint64_t _res) {
16992 if (!ptr_is_owned(_res)) return;
16993 void* _res_ptr = untag_ptr(_res);
16994 CHECK_ACCESS(_res_ptr);
16995 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(_res_ptr);
16996 FREE(untag_ptr(_res));
16997 CResult_TransactionNoneZ_free(_res_conv);
17000 static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
17001 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
17002 *ret_conv = CResult_TransactionNoneZ_clone(arg);
17003 return tag_ptr(ret_conv, true);
17005 int64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone_ptr"))) TS_CResult_TransactionNoneZ_clone_ptr(uint64_t arg) {
17006 LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(arg);
17007 int64_t ret_conv = CResult_TransactionNoneZ_clone_ptr(arg_conv);
17011 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone"))) TS_CResult_TransactionNoneZ_clone(uint64_t orig) {
17012 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(orig);
17013 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
17014 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
17015 return tag_ptr(ret_conv, true);
17018 uint64_t __attribute__((export_name("TS_COption_u16Z_some"))) TS_COption_u16Z_some(int16_t o) {
17019 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17020 *ret_copy = COption_u16Z_some(o);
17021 uint64_t ret_ref = tag_ptr(ret_copy, true);
17025 uint64_t __attribute__((export_name("TS_COption_u16Z_none"))) TS_COption_u16Z_none() {
17026 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17027 *ret_copy = COption_u16Z_none();
17028 uint64_t ret_ref = tag_ptr(ret_copy, true);
17032 void __attribute__((export_name("TS_COption_u16Z_free"))) TS_COption_u16Z_free(uint64_t _res) {
17033 if (!ptr_is_owned(_res)) return;
17034 void* _res_ptr = untag_ptr(_res);
17035 CHECK_ACCESS(_res_ptr);
17036 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(_res_ptr);
17037 FREE(untag_ptr(_res));
17038 COption_u16Z_free(_res_conv);
17041 static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
17042 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17043 *ret_copy = COption_u16Z_clone(arg);
17044 uint64_t ret_ref = tag_ptr(ret_copy, true);
17047 int64_t __attribute__((export_name("TS_COption_u16Z_clone_ptr"))) TS_COption_u16Z_clone_ptr(uint64_t arg) {
17048 LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)untag_ptr(arg);
17049 int64_t ret_conv = COption_u16Z_clone_ptr(arg_conv);
17053 uint64_t __attribute__((export_name("TS_COption_u16Z_clone"))) TS_COption_u16Z_clone(uint64_t orig) {
17054 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)untag_ptr(orig);
17055 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
17056 *ret_copy = COption_u16Z_clone(orig_conv);
17057 uint64_t ret_ref = tag_ptr(ret_copy, true);
17061 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_ok"))) TS_CResult__u832APIErrorZ_ok(int8_tArray o) {
17062 LDKThirtyTwoBytes o_ref;
17063 CHECK(o->arr_len == 32);
17064 memcpy(o_ref.data, o->elems, 32); FREE(o);
17065 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17066 *ret_conv = CResult__u832APIErrorZ_ok(o_ref);
17067 return tag_ptr(ret_conv, true);
17070 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_err"))) TS_CResult__u832APIErrorZ_err(uint64_t e) {
17071 void* e_ptr = untag_ptr(e);
17072 CHECK_ACCESS(e_ptr);
17073 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17074 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17075 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17076 *ret_conv = CResult__u832APIErrorZ_err(e_conv);
17077 return tag_ptr(ret_conv, true);
17080 jboolean __attribute__((export_name("TS_CResult__u832APIErrorZ_is_ok"))) TS_CResult__u832APIErrorZ_is_ok(uint64_t o) {
17081 LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(o);
17082 jboolean ret_conv = CResult__u832APIErrorZ_is_ok(o_conv);
17086 void __attribute__((export_name("TS_CResult__u832APIErrorZ_free"))) TS_CResult__u832APIErrorZ_free(uint64_t _res) {
17087 if (!ptr_is_owned(_res)) return;
17088 void* _res_ptr = untag_ptr(_res);
17089 CHECK_ACCESS(_res_ptr);
17090 LDKCResult__u832APIErrorZ _res_conv = *(LDKCResult__u832APIErrorZ*)(_res_ptr);
17091 FREE(untag_ptr(_res));
17092 CResult__u832APIErrorZ_free(_res_conv);
17095 static inline uint64_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
17096 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17097 *ret_conv = CResult__u832APIErrorZ_clone(arg);
17098 return tag_ptr(ret_conv, true);
17100 int64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone_ptr"))) TS_CResult__u832APIErrorZ_clone_ptr(uint64_t arg) {
17101 LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(arg);
17102 int64_t ret_conv = CResult__u832APIErrorZ_clone_ptr(arg_conv);
17106 uint64_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone"))) TS_CResult__u832APIErrorZ_clone(uint64_t orig) {
17107 LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)untag_ptr(orig);
17108 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
17109 *ret_conv = CResult__u832APIErrorZ_clone(orig_conv);
17110 return tag_ptr(ret_conv, true);
17113 void __attribute__((export_name("TS_CVec_RecentPaymentDetailsZ_free"))) TS_CVec_RecentPaymentDetailsZ_free(uint64_tArray _res) {
17114 LDKCVec_RecentPaymentDetailsZ _res_constr;
17115 _res_constr.datalen = _res->arr_len;
17116 if (_res_constr.datalen > 0)
17117 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRecentPaymentDetails), "LDKCVec_RecentPaymentDetailsZ Elements");
17119 _res_constr.data = NULL;
17120 uint64_t* _res_vals = _res->elems;
17121 for (size_t w = 0; w < _res_constr.datalen; w++) {
17122 uint64_t _res_conv_22 = _res_vals[w];
17123 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
17124 CHECK_ACCESS(_res_conv_22_ptr);
17125 LDKRecentPaymentDetails _res_conv_22_conv = *(LDKRecentPaymentDetails*)(_res_conv_22_ptr);
17126 FREE(untag_ptr(_res_conv_22));
17127 _res_constr.data[w] = _res_conv_22_conv;
17130 CVec_RecentPaymentDetailsZ_free(_res_constr);
17133 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_ok"))) TS_CResult_NonePaymentSendFailureZ_ok() {
17134 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17135 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
17136 return tag_ptr(ret_conv, true);
17139 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_err"))) TS_CResult_NonePaymentSendFailureZ_err(uint64_t e) {
17140 void* e_ptr = untag_ptr(e);
17141 CHECK_ACCESS(e_ptr);
17142 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
17143 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
17144 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17145 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
17146 return tag_ptr(ret_conv, true);
17149 jboolean __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_is_ok"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint64_t o) {
17150 LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(o);
17151 jboolean ret_conv = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
17155 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_free"))) TS_CResult_NonePaymentSendFailureZ_free(uint64_t _res) {
17156 if (!ptr_is_owned(_res)) return;
17157 void* _res_ptr = untag_ptr(_res);
17158 CHECK_ACCESS(_res_ptr);
17159 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(_res_ptr);
17160 FREE(untag_ptr(_res));
17161 CResult_NonePaymentSendFailureZ_free(_res_conv);
17164 static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
17165 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17166 *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
17167 return tag_ptr(ret_conv, true);
17169 int64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone_ptr"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint64_t arg) {
17170 LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(arg);
17171 int64_t ret_conv = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
17175 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone"))) TS_CResult_NonePaymentSendFailureZ_clone(uint64_t orig) {
17176 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(orig);
17177 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
17178 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
17179 return tag_ptr(ret_conv, true);
17182 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_ok"))) TS_CResult_NoneRetryableSendFailureZ_ok() {
17183 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17184 *ret_conv = CResult_NoneRetryableSendFailureZ_ok();
17185 return tag_ptr(ret_conv, true);
17188 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_err"))) TS_CResult_NoneRetryableSendFailureZ_err(uint32_t e) {
17189 LDKRetryableSendFailure e_conv = LDKRetryableSendFailure_from_js(e);
17190 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17191 *ret_conv = CResult_NoneRetryableSendFailureZ_err(e_conv);
17192 return tag_ptr(ret_conv, true);
17195 jboolean __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_is_ok"))) TS_CResult_NoneRetryableSendFailureZ_is_ok(uint64_t o) {
17196 LDKCResult_NoneRetryableSendFailureZ* o_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(o);
17197 jboolean ret_conv = CResult_NoneRetryableSendFailureZ_is_ok(o_conv);
17201 void __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_free"))) TS_CResult_NoneRetryableSendFailureZ_free(uint64_t _res) {
17202 if (!ptr_is_owned(_res)) return;
17203 void* _res_ptr = untag_ptr(_res);
17204 CHECK_ACCESS(_res_ptr);
17205 LDKCResult_NoneRetryableSendFailureZ _res_conv = *(LDKCResult_NoneRetryableSendFailureZ*)(_res_ptr);
17206 FREE(untag_ptr(_res));
17207 CResult_NoneRetryableSendFailureZ_free(_res_conv);
17210 static inline uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg) {
17211 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17212 *ret_conv = CResult_NoneRetryableSendFailureZ_clone(arg);
17213 return tag_ptr(ret_conv, true);
17215 int64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_clone_ptr"))) TS_CResult_NoneRetryableSendFailureZ_clone_ptr(uint64_t arg) {
17216 LDKCResult_NoneRetryableSendFailureZ* arg_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(arg);
17217 int64_t ret_conv = CResult_NoneRetryableSendFailureZ_clone_ptr(arg_conv);
17221 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_clone"))) TS_CResult_NoneRetryableSendFailureZ_clone(uint64_t orig) {
17222 LDKCResult_NoneRetryableSendFailureZ* orig_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(orig);
17223 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
17224 *ret_conv = CResult_NoneRetryableSendFailureZ_clone(orig_conv);
17225 return tag_ptr(ret_conv, true);
17228 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_ok(int8_tArray o) {
17229 LDKThirtyTwoBytes o_ref;
17230 CHECK(o->arr_len == 32);
17231 memcpy(o_ref.data, o->elems, 32); FREE(o);
17232 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17233 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_ok(o_ref);
17234 return tag_ptr(ret_conv, true);
17237 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_err"))) TS_CResult_PaymentHashPaymentSendFailureZ_err(uint64_t e) {
17238 void* e_ptr = untag_ptr(e);
17239 CHECK_ACCESS(e_ptr);
17240 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
17241 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
17242 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17243 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_err(e_conv);
17244 return tag_ptr(ret_conv, true);
17247 jboolean __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_is_ok"))) TS_CResult_PaymentHashPaymentSendFailureZ_is_ok(uint64_t o) {
17248 LDKCResult_PaymentHashPaymentSendFailureZ* o_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(o);
17249 jboolean ret_conv = CResult_PaymentHashPaymentSendFailureZ_is_ok(o_conv);
17253 void __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_free"))) TS_CResult_PaymentHashPaymentSendFailureZ_free(uint64_t _res) {
17254 if (!ptr_is_owned(_res)) return;
17255 void* _res_ptr = untag_ptr(_res);
17256 CHECK_ACCESS(_res_ptr);
17257 LDKCResult_PaymentHashPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentHashPaymentSendFailureZ*)(_res_ptr);
17258 FREE(untag_ptr(_res));
17259 CResult_PaymentHashPaymentSendFailureZ_free(_res_conv);
17262 static inline uint64_t CResult_PaymentHashPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR arg) {
17263 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17264 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(arg);
17265 return tag_ptr(ret_conv, true);
17267 int64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone_ptr(uint64_t arg) {
17268 LDKCResult_PaymentHashPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(arg);
17269 int64_t ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone_ptr(arg_conv);
17273 uint64_t __attribute__((export_name("TS_CResult_PaymentHashPaymentSendFailureZ_clone"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone(uint64_t orig) {
17274 LDKCResult_PaymentHashPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)untag_ptr(orig);
17275 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
17276 *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(orig_conv);
17277 return tag_ptr(ret_conv, true);
17280 uint64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_ok"))) TS_CResult_PaymentHashRetryableSendFailureZ_ok(int8_tArray o) {
17281 LDKThirtyTwoBytes o_ref;
17282 CHECK(o->arr_len == 32);
17283 memcpy(o_ref.data, o->elems, 32); FREE(o);
17284 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17285 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_ok(o_ref);
17286 return tag_ptr(ret_conv, true);
17289 uint64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_err"))) TS_CResult_PaymentHashRetryableSendFailureZ_err(uint32_t e) {
17290 LDKRetryableSendFailure e_conv = LDKRetryableSendFailure_from_js(e);
17291 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17292 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_err(e_conv);
17293 return tag_ptr(ret_conv, true);
17296 jboolean __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_is_ok"))) TS_CResult_PaymentHashRetryableSendFailureZ_is_ok(uint64_t o) {
17297 LDKCResult_PaymentHashRetryableSendFailureZ* o_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(o);
17298 jboolean ret_conv = CResult_PaymentHashRetryableSendFailureZ_is_ok(o_conv);
17302 void __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_free"))) TS_CResult_PaymentHashRetryableSendFailureZ_free(uint64_t _res) {
17303 if (!ptr_is_owned(_res)) return;
17304 void* _res_ptr = untag_ptr(_res);
17305 CHECK_ACCESS(_res_ptr);
17306 LDKCResult_PaymentHashRetryableSendFailureZ _res_conv = *(LDKCResult_PaymentHashRetryableSendFailureZ*)(_res_ptr);
17307 FREE(untag_ptr(_res));
17308 CResult_PaymentHashRetryableSendFailureZ_free(_res_conv);
17311 static inline uint64_t CResult_PaymentHashRetryableSendFailureZ_clone_ptr(LDKCResult_PaymentHashRetryableSendFailureZ *NONNULL_PTR arg) {
17312 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17313 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_clone(arg);
17314 return tag_ptr(ret_conv, true);
17316 int64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_clone_ptr"))) TS_CResult_PaymentHashRetryableSendFailureZ_clone_ptr(uint64_t arg) {
17317 LDKCResult_PaymentHashRetryableSendFailureZ* arg_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(arg);
17318 int64_t ret_conv = CResult_PaymentHashRetryableSendFailureZ_clone_ptr(arg_conv);
17322 uint64_t __attribute__((export_name("TS_CResult_PaymentHashRetryableSendFailureZ_clone"))) TS_CResult_PaymentHashRetryableSendFailureZ_clone(uint64_t orig) {
17323 LDKCResult_PaymentHashRetryableSendFailureZ* orig_conv = (LDKCResult_PaymentHashRetryableSendFailureZ*)untag_ptr(orig);
17324 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
17325 *ret_conv = CResult_PaymentHashRetryableSendFailureZ_clone(orig_conv);
17326 return tag_ptr(ret_conv, true);
17329 static inline uint64_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
17330 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
17331 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
17332 return tag_ptr(ret_conv, true);
17334 int64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint64_t arg) {
17335 LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(arg);
17336 int64_t ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
17340 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint64_t orig) {
17341 LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(orig);
17342 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
17343 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(orig_conv);
17344 return tag_ptr(ret_conv, true);
17347 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_new"))) TS_C2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, int8_tArray b) {
17348 LDKThirtyTwoBytes a_ref;
17349 CHECK(a->arr_len == 32);
17350 memcpy(a_ref.data, a->elems, 32); FREE(a);
17351 LDKThirtyTwoBytes b_ref;
17352 CHECK(b->arr_len == 32);
17353 memcpy(b_ref.data, b->elems, 32); FREE(b);
17354 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
17355 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_new(a_ref, b_ref);
17356 return tag_ptr(ret_conv, true);
17359 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_free"))) TS_C2Tuple_PaymentHashPaymentIdZ_free(uint64_t _res) {
17360 if (!ptr_is_owned(_res)) return;
17361 void* _res_ptr = untag_ptr(_res);
17362 CHECK_ACCESS(_res_ptr);
17363 LDKC2Tuple_PaymentHashPaymentIdZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(_res_ptr);
17364 FREE(untag_ptr(_res));
17365 C2Tuple_PaymentHashPaymentIdZ_free(_res_conv);
17368 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(uint64_t o) {
17369 void* o_ptr = untag_ptr(o);
17370 CHECK_ACCESS(o_ptr);
17371 LDKC2Tuple_PaymentHashPaymentIdZ o_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(o_ptr);
17372 o_conv = C2Tuple_PaymentHashPaymentIdZ_clone((LDKC2Tuple_PaymentHashPaymentIdZ*)untag_ptr(o));
17373 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17374 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o_conv);
17375 return tag_ptr(ret_conv, true);
17378 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(uint64_t e) {
17379 void* e_ptr = untag_ptr(e);
17380 CHECK_ACCESS(e_ptr);
17381 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
17382 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
17383 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17384 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e_conv);
17385 return tag_ptr(ret_conv, true);
17388 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint64_t o) {
17389 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(o);
17390 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
17394 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint64_t _res) {
17395 if (!ptr_is_owned(_res)) return;
17396 void* _res_ptr = untag_ptr(_res);
17397 CHECK_ACCESS(_res_ptr);
17398 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(_res_ptr);
17399 FREE(untag_ptr(_res));
17400 CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
17403 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
17404 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17405 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
17406 return tag_ptr(ret_conv, true);
17408 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint64_t arg) {
17409 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(arg);
17410 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
17414 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint64_t orig) {
17415 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)untag_ptr(orig);
17416 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
17417 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig_conv);
17418 return tag_ptr(ret_conv, true);
17421 void __attribute__((export_name("TS_CVec_ThirtyTwoBytesZ_free"))) TS_CVec_ThirtyTwoBytesZ_free(ptrArray _res) {
17422 LDKCVec_ThirtyTwoBytesZ _res_constr;
17423 _res_constr.datalen = _res->arr_len;
17424 if (_res_constr.datalen > 0)
17425 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
17427 _res_constr.data = NULL;
17428 int8_tArray* _res_vals = (void*) _res->elems;
17429 for (size_t m = 0; m < _res_constr.datalen; m++) {
17430 int8_tArray _res_conv_12 = _res_vals[m];
17431 LDKThirtyTwoBytes _res_conv_12_ref;
17432 CHECK(_res_conv_12->arr_len == 32);
17433 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
17434 _res_constr.data[m] = _res_conv_12_ref;
17437 CVec_ThirtyTwoBytesZ_free(_res_constr);
17440 static inline uint64_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
17441 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
17442 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
17443 return tag_ptr(ret_conv, true);
17445 int64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint64_t arg) {
17446 LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(arg);
17447 int64_t ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
17451 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint64_t orig) {
17452 LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(orig);
17453 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
17454 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
17455 return tag_ptr(ret_conv, true);
17458 uint64_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_new"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
17459 LDKThirtyTwoBytes a_ref;
17460 CHECK(a->arr_len == 32);
17461 memcpy(a_ref.data, a->elems, 32); FREE(a);
17462 LDKThirtyTwoBytes b_ref;
17463 CHECK(b->arr_len == 32);
17464 memcpy(b_ref.data, b->elems, 32); FREE(b);
17465 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
17466 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
17467 return tag_ptr(ret_conv, true);
17470 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_free"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint64_t _res) {
17471 if (!ptr_is_owned(_res)) return;
17472 void* _res_ptr = untag_ptr(_res);
17473 CHECK_ACCESS(_res_ptr);
17474 LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(_res_ptr);
17475 FREE(untag_ptr(_res));
17476 C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
17479 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(uint64_t o) {
17480 void* o_ptr = untag_ptr(o);
17481 CHECK_ACCESS(o_ptr);
17482 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
17483 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(o));
17484 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17485 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o_conv);
17486 return tag_ptr(ret_conv, true);
17489 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err() {
17490 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17491 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
17492 return tag_ptr(ret_conv, true);
17495 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(uint64_t o) {
17496 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(o);
17497 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o_conv);
17501 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(uint64_t _res) {
17502 if (!ptr_is_owned(_res)) return;
17503 void* _res_ptr = untag_ptr(_res);
17504 CHECK_ACCESS(_res_ptr);
17505 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(_res_ptr);
17506 FREE(untag_ptr(_res));
17507 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res_conv);
17510 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg) {
17511 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17512 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(arg);
17513 return tag_ptr(ret_conv, true);
17515 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(uint64_t arg) {
17516 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(arg);
17517 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg_conv);
17521 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(uint64_t orig) {
17522 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)untag_ptr(orig);
17523 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
17524 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig_conv);
17525 return tag_ptr(ret_conv, true);
17528 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(uint64_t o) {
17529 void* o_ptr = untag_ptr(o);
17530 CHECK_ACCESS(o_ptr);
17531 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
17532 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)untag_ptr(o));
17533 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17534 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o_conv);
17535 return tag_ptr(ret_conv, true);
17538 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(uint64_t e) {
17539 void* e_ptr = untag_ptr(e);
17540 CHECK_ACCESS(e_ptr);
17541 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17542 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17543 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17544 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e_conv);
17545 return tag_ptr(ret_conv, true);
17548 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(uint64_t o) {
17549 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(o);
17550 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o_conv);
17554 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(uint64_t _res) {
17555 if (!ptr_is_owned(_res)) return;
17556 void* _res_ptr = untag_ptr(_res);
17557 CHECK_ACCESS(_res_ptr);
17558 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(_res_ptr);
17559 FREE(untag_ptr(_res));
17560 CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res_conv);
17563 static inline uint64_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg) {
17564 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17565 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(arg);
17566 return tag_ptr(ret_conv, true);
17568 int64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(uint64_t arg) {
17569 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(arg);
17570 int64_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg_conv);
17574 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(uint64_t orig) {
17575 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)untag_ptr(orig);
17576 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
17577 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig_conv);
17578 return tag_ptr(ret_conv, true);
17581 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_ok"))) TS_CResult_PaymentSecretNoneZ_ok(int8_tArray o) {
17582 LDKThirtyTwoBytes o_ref;
17583 CHECK(o->arr_len == 32);
17584 memcpy(o_ref.data, o->elems, 32); FREE(o);
17585 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17586 *ret_conv = CResult_PaymentSecretNoneZ_ok(o_ref);
17587 return tag_ptr(ret_conv, true);
17590 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_err"))) TS_CResult_PaymentSecretNoneZ_err() {
17591 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17592 *ret_conv = CResult_PaymentSecretNoneZ_err();
17593 return tag_ptr(ret_conv, true);
17596 jboolean __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_is_ok"))) TS_CResult_PaymentSecretNoneZ_is_ok(uint64_t o) {
17597 LDKCResult_PaymentSecretNoneZ* o_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(o);
17598 jboolean ret_conv = CResult_PaymentSecretNoneZ_is_ok(o_conv);
17602 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_free"))) TS_CResult_PaymentSecretNoneZ_free(uint64_t _res) {
17603 if (!ptr_is_owned(_res)) return;
17604 void* _res_ptr = untag_ptr(_res);
17605 CHECK_ACCESS(_res_ptr);
17606 LDKCResult_PaymentSecretNoneZ _res_conv = *(LDKCResult_PaymentSecretNoneZ*)(_res_ptr);
17607 FREE(untag_ptr(_res));
17608 CResult_PaymentSecretNoneZ_free(_res_conv);
17611 static inline uint64_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg) {
17612 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17613 *ret_conv = CResult_PaymentSecretNoneZ_clone(arg);
17614 return tag_ptr(ret_conv, true);
17616 int64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone_ptr"))) TS_CResult_PaymentSecretNoneZ_clone_ptr(uint64_t arg) {
17617 LDKCResult_PaymentSecretNoneZ* arg_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(arg);
17618 int64_t ret_conv = CResult_PaymentSecretNoneZ_clone_ptr(arg_conv);
17622 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone"))) TS_CResult_PaymentSecretNoneZ_clone(uint64_t orig) {
17623 LDKCResult_PaymentSecretNoneZ* orig_conv = (LDKCResult_PaymentSecretNoneZ*)untag_ptr(orig);
17624 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
17625 *ret_conv = CResult_PaymentSecretNoneZ_clone(orig_conv);
17626 return tag_ptr(ret_conv, true);
17629 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_ok"))) TS_CResult_PaymentSecretAPIErrorZ_ok(int8_tArray o) {
17630 LDKThirtyTwoBytes o_ref;
17631 CHECK(o->arr_len == 32);
17632 memcpy(o_ref.data, o->elems, 32); FREE(o);
17633 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17634 *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
17635 return tag_ptr(ret_conv, true);
17638 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_err"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint64_t e) {
17639 void* e_ptr = untag_ptr(e);
17640 CHECK_ACCESS(e_ptr);
17641 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17642 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17643 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17644 *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
17645 return tag_ptr(ret_conv, true);
17648 jboolean __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_is_ok"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint64_t o) {
17649 LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(o);
17650 jboolean ret_conv = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
17654 void __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_free"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint64_t _res) {
17655 if (!ptr_is_owned(_res)) return;
17656 void* _res_ptr = untag_ptr(_res);
17657 CHECK_ACCESS(_res_ptr);
17658 LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(_res_ptr);
17659 FREE(untag_ptr(_res));
17660 CResult_PaymentSecretAPIErrorZ_free(_res_conv);
17663 static inline uint64_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
17664 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17665 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
17666 return tag_ptr(ret_conv, true);
17668 int64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone_ptr"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint64_t arg) {
17669 LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(arg);
17670 int64_t ret_conv = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
17674 uint64_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint64_t orig) {
17675 LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)untag_ptr(orig);
17676 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
17677 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
17678 return tag_ptr(ret_conv, true);
17681 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_ok(int8_tArray o) {
17682 LDKThirtyTwoBytes o_ref;
17683 CHECK(o->arr_len == 32);
17684 memcpy(o_ref.data, o->elems, 32); FREE(o);
17685 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17686 *ret_conv = CResult_PaymentPreimageAPIErrorZ_ok(o_ref);
17687 return tag_ptr(ret_conv, true);
17690 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_err"))) TS_CResult_PaymentPreimageAPIErrorZ_err(uint64_t e) {
17691 void* e_ptr = untag_ptr(e);
17692 CHECK_ACCESS(e_ptr);
17693 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
17694 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
17695 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17696 *ret_conv = CResult_PaymentPreimageAPIErrorZ_err(e_conv);
17697 return tag_ptr(ret_conv, true);
17700 jboolean __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_is_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_is_ok(uint64_t o) {
17701 LDKCResult_PaymentPreimageAPIErrorZ* o_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(o);
17702 jboolean ret_conv = CResult_PaymentPreimageAPIErrorZ_is_ok(o_conv);
17706 void __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_free"))) TS_CResult_PaymentPreimageAPIErrorZ_free(uint64_t _res) {
17707 if (!ptr_is_owned(_res)) return;
17708 void* _res_ptr = untag_ptr(_res);
17709 CHECK_ACCESS(_res_ptr);
17710 LDKCResult_PaymentPreimageAPIErrorZ _res_conv = *(LDKCResult_PaymentPreimageAPIErrorZ*)(_res_ptr);
17711 FREE(untag_ptr(_res));
17712 CResult_PaymentPreimageAPIErrorZ_free(_res_conv);
17715 static inline uint64_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg) {
17716 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17717 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(arg);
17718 return tag_ptr(ret_conv, true);
17720 int64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr"))) TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(uint64_t arg) {
17721 LDKCResult_PaymentPreimageAPIErrorZ* arg_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(arg);
17722 int64_t ret_conv = CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg_conv);
17726 uint64_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone"))) TS_CResult_PaymentPreimageAPIErrorZ_clone(uint64_t orig) {
17727 LDKCResult_PaymentPreimageAPIErrorZ* orig_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)untag_ptr(orig);
17728 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
17729 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(orig_conv);
17730 return tag_ptr(ret_conv, true);
17733 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(uint64_t o) {
17734 LDKCounterpartyForwardingInfo o_conv;
17735 o_conv.inner = untag_ptr(o);
17736 o_conv.is_owned = ptr_is_owned(o);
17737 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17738 o_conv = CounterpartyForwardingInfo_clone(&o_conv);
17739 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17740 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o_conv);
17741 return tag_ptr(ret_conv, true);
17744 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(uint64_t e) {
17745 void* e_ptr = untag_ptr(e);
17746 CHECK_ACCESS(e_ptr);
17747 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17748 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17749 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17750 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e_conv);
17751 return tag_ptr(ret_conv, true);
17754 jboolean __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(uint64_t o) {
17755 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* o_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(o);
17756 jboolean ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o_conv);
17760 void __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(uint64_t _res) {
17761 if (!ptr_is_owned(_res)) return;
17762 void* _res_ptr = untag_ptr(_res);
17763 CHECK_ACCESS(_res_ptr);
17764 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(_res_ptr);
17765 FREE(untag_ptr(_res));
17766 CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res_conv);
17769 static inline uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg) {
17770 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17771 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(arg);
17772 return tag_ptr(ret_conv, true);
17774 int64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
17775 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(arg);
17776 int64_t ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg_conv);
17780 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(uint64_t orig) {
17781 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(orig);
17782 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
17783 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig_conv);
17784 return tag_ptr(ret_conv, true);
17787 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(uint64_t o) {
17788 LDKChannelCounterparty o_conv;
17789 o_conv.inner = untag_ptr(o);
17790 o_conv.is_owned = ptr_is_owned(o);
17791 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17792 o_conv = ChannelCounterparty_clone(&o_conv);
17793 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17794 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_ok(o_conv);
17795 return tag_ptr(ret_conv, true);
17798 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_err(uint64_t e) {
17799 void* e_ptr = untag_ptr(e);
17800 CHECK_ACCESS(e_ptr);
17801 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17802 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17803 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17804 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_err(e_conv);
17805 return tag_ptr(ret_conv, true);
17808 jboolean __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(uint64_t o) {
17809 LDKCResult_ChannelCounterpartyDecodeErrorZ* o_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(o);
17810 jboolean ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o_conv);
17814 void __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_free"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_free(uint64_t _res) {
17815 if (!ptr_is_owned(_res)) return;
17816 void* _res_ptr = untag_ptr(_res);
17817 CHECK_ACCESS(_res_ptr);
17818 LDKCResult_ChannelCounterpartyDecodeErrorZ _res_conv = *(LDKCResult_ChannelCounterpartyDecodeErrorZ*)(_res_ptr);
17819 FREE(untag_ptr(_res));
17820 CResult_ChannelCounterpartyDecodeErrorZ_free(_res_conv);
17823 static inline uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg) {
17824 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17825 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(arg);
17826 return tag_ptr(ret_conv, true);
17828 int64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(uint64_t arg) {
17829 LDKCResult_ChannelCounterpartyDecodeErrorZ* arg_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(arg);
17830 int64_t ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg_conv);
17834 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(uint64_t orig) {
17835 LDKCResult_ChannelCounterpartyDecodeErrorZ* orig_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(orig);
17836 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
17837 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(orig_conv);
17838 return tag_ptr(ret_conv, true);
17841 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_ok(uint64_t o) {
17842 LDKChannelDetails o_conv;
17843 o_conv.inner = untag_ptr(o);
17844 o_conv.is_owned = ptr_is_owned(o);
17845 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17846 o_conv = ChannelDetails_clone(&o_conv);
17847 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17848 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_ok(o_conv);
17849 return tag_ptr(ret_conv, true);
17852 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_err(uint64_t e) {
17853 void* e_ptr = untag_ptr(e);
17854 CHECK_ACCESS(e_ptr);
17855 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17856 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17857 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17858 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_err(e_conv);
17859 return tag_ptr(ret_conv, true);
17862 jboolean __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_is_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(uint64_t o) {
17863 LDKCResult_ChannelDetailsDecodeErrorZ* o_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(o);
17864 jboolean ret_conv = CResult_ChannelDetailsDecodeErrorZ_is_ok(o_conv);
17868 void __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_free"))) TS_CResult_ChannelDetailsDecodeErrorZ_free(uint64_t _res) {
17869 if (!ptr_is_owned(_res)) return;
17870 void* _res_ptr = untag_ptr(_res);
17871 CHECK_ACCESS(_res_ptr);
17872 LDKCResult_ChannelDetailsDecodeErrorZ _res_conv = *(LDKCResult_ChannelDetailsDecodeErrorZ*)(_res_ptr);
17873 FREE(untag_ptr(_res));
17874 CResult_ChannelDetailsDecodeErrorZ_free(_res_conv);
17877 static inline uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg) {
17878 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17879 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(arg);
17880 return tag_ptr(ret_conv, true);
17882 int64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(uint64_t arg) {
17883 LDKCResult_ChannelDetailsDecodeErrorZ* arg_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(arg);
17884 int64_t ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg_conv);
17888 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone(uint64_t orig) {
17889 LDKCResult_ChannelDetailsDecodeErrorZ* orig_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(orig);
17890 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
17891 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(orig_conv);
17892 return tag_ptr(ret_conv, true);
17895 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(uint64_t o) {
17896 LDKPhantomRouteHints o_conv;
17897 o_conv.inner = untag_ptr(o);
17898 o_conv.is_owned = ptr_is_owned(o);
17899 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17900 o_conv = PhantomRouteHints_clone(&o_conv);
17901 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17902 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_ok(o_conv);
17903 return tag_ptr(ret_conv, true);
17906 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_err(uint64_t e) {
17907 void* e_ptr = untag_ptr(e);
17908 CHECK_ACCESS(e_ptr);
17909 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17910 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17911 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17912 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_err(e_conv);
17913 return tag_ptr(ret_conv, true);
17916 jboolean __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(uint64_t o) {
17917 LDKCResult_PhantomRouteHintsDecodeErrorZ* o_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(o);
17918 jboolean ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o_conv);
17922 void __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_free"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_free(uint64_t _res) {
17923 if (!ptr_is_owned(_res)) return;
17924 void* _res_ptr = untag_ptr(_res);
17925 CHECK_ACCESS(_res_ptr);
17926 LDKCResult_PhantomRouteHintsDecodeErrorZ _res_conv = *(LDKCResult_PhantomRouteHintsDecodeErrorZ*)(_res_ptr);
17927 FREE(untag_ptr(_res));
17928 CResult_PhantomRouteHintsDecodeErrorZ_free(_res_conv);
17931 static inline uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg) {
17932 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17933 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(arg);
17934 return tag_ptr(ret_conv, true);
17936 int64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(uint64_t arg) {
17937 LDKCResult_PhantomRouteHintsDecodeErrorZ* arg_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(arg);
17938 int64_t ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg_conv);
17942 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(uint64_t orig) {
17943 LDKCResult_PhantomRouteHintsDecodeErrorZ* orig_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(orig);
17944 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
17945 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(orig_conv);
17946 return tag_ptr(ret_conv, true);
17949 void __attribute__((export_name("TS_CVec_ChannelMonitorZ_free"))) TS_CVec_ChannelMonitorZ_free(uint64_tArray _res) {
17950 LDKCVec_ChannelMonitorZ _res_constr;
17951 _res_constr.datalen = _res->arr_len;
17952 if (_res_constr.datalen > 0)
17953 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
17955 _res_constr.data = NULL;
17956 uint64_t* _res_vals = _res->elems;
17957 for (size_t q = 0; q < _res_constr.datalen; q++) {
17958 uint64_t _res_conv_16 = _res_vals[q];
17959 LDKChannelMonitor _res_conv_16_conv;
17960 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
17961 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
17962 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
17963 _res_constr.data[q] = _res_conv_16_conv;
17966 CVec_ChannelMonitorZ_free(_res_constr);
17969 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_new"))) TS_C2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint64_t b) {
17970 LDKThirtyTwoBytes a_ref;
17971 CHECK(a->arr_len == 32);
17972 memcpy(a_ref.data, a->elems, 32); FREE(a);
17973 LDKChannelManager b_conv;
17974 b_conv.inner = untag_ptr(b);
17975 b_conv.is_owned = ptr_is_owned(b);
17976 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
17977 // WARNING: we need a move here but no clone is available for LDKChannelManager
17979 LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
17980 *ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
17981 return tag_ptr(ret_conv, true);
17984 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_free"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint64_t _res) {
17985 if (!ptr_is_owned(_res)) return;
17986 void* _res_ptr = untag_ptr(_res);
17987 CHECK_ACCESS(_res_ptr);
17988 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(_res_ptr);
17989 FREE(untag_ptr(_res));
17990 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
17993 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint64_t o) {
17994 void* o_ptr = untag_ptr(o);
17995 CHECK_ACCESS(o_ptr);
17996 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(o_ptr);
17997 // WARNING: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ
17998 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
17999 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
18000 return tag_ptr(ret_conv, true);
18003 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(uint64_t e) {
18004 void* e_ptr = untag_ptr(e);
18005 CHECK_ACCESS(e_ptr);
18006 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18007 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18008 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
18009 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
18010 return tag_ptr(ret_conv, true);
18013 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint64_t o) {
18014 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)untag_ptr(o);
18015 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
18019 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint64_t _res) {
18020 if (!ptr_is_owned(_res)) return;
18021 void* _res_ptr = untag_ptr(_res);
18022 CHECK_ACCESS(_res_ptr);
18023 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(_res_ptr);
18024 FREE(untag_ptr(_res));
18025 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
18028 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint64_t o) {
18029 LDKChannelConfig o_conv;
18030 o_conv.inner = untag_ptr(o);
18031 o_conv.is_owned = ptr_is_owned(o);
18032 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18033 o_conv = ChannelConfig_clone(&o_conv);
18034 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18035 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
18036 return tag_ptr(ret_conv, true);
18039 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_err"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint64_t e) {
18040 void* e_ptr = untag_ptr(e);
18041 CHECK_ACCESS(e_ptr);
18042 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18043 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18044 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18045 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
18046 return tag_ptr(ret_conv, true);
18049 jboolean __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_is_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint64_t o) {
18050 LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(o);
18051 jboolean ret_conv = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
18055 void __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_free"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint64_t _res) {
18056 if (!ptr_is_owned(_res)) return;
18057 void* _res_ptr = untag_ptr(_res);
18058 CHECK_ACCESS(_res_ptr);
18059 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(_res_ptr);
18060 FREE(untag_ptr(_res));
18061 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
18064 static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
18065 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18066 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
18067 return tag_ptr(ret_conv, true);
18069 int64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint64_t arg) {
18070 LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(arg);
18071 int64_t ret_conv = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
18075 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint64_t orig) {
18076 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(orig);
18077 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
18078 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
18079 return tag_ptr(ret_conv, true);
18082 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_some"))) TS_COption_APIErrorZ_some(uint64_t o) {
18083 void* o_ptr = untag_ptr(o);
18084 CHECK_ACCESS(o_ptr);
18085 LDKAPIError o_conv = *(LDKAPIError*)(o_ptr);
18086 o_conv = APIError_clone((LDKAPIError*)untag_ptr(o));
18087 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18088 *ret_copy = COption_APIErrorZ_some(o_conv);
18089 uint64_t ret_ref = tag_ptr(ret_copy, true);
18093 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_none"))) TS_COption_APIErrorZ_none() {
18094 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18095 *ret_copy = COption_APIErrorZ_none();
18096 uint64_t ret_ref = tag_ptr(ret_copy, true);
18100 void __attribute__((export_name("TS_COption_APIErrorZ_free"))) TS_COption_APIErrorZ_free(uint64_t _res) {
18101 if (!ptr_is_owned(_res)) return;
18102 void* _res_ptr = untag_ptr(_res);
18103 CHECK_ACCESS(_res_ptr);
18104 LDKCOption_APIErrorZ _res_conv = *(LDKCOption_APIErrorZ*)(_res_ptr);
18105 FREE(untag_ptr(_res));
18106 COption_APIErrorZ_free(_res_conv);
18109 static inline uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg) {
18110 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18111 *ret_copy = COption_APIErrorZ_clone(arg);
18112 uint64_t ret_ref = tag_ptr(ret_copy, true);
18115 int64_t __attribute__((export_name("TS_COption_APIErrorZ_clone_ptr"))) TS_COption_APIErrorZ_clone_ptr(uint64_t arg) {
18116 LDKCOption_APIErrorZ* arg_conv = (LDKCOption_APIErrorZ*)untag_ptr(arg);
18117 int64_t ret_conv = COption_APIErrorZ_clone_ptr(arg_conv);
18121 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_clone"))) TS_COption_APIErrorZ_clone(uint64_t orig) {
18122 LDKCOption_APIErrorZ* orig_conv = (LDKCOption_APIErrorZ*)untag_ptr(orig);
18123 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
18124 *ret_copy = COption_APIErrorZ_clone(orig_conv);
18125 uint64_t ret_ref = tag_ptr(ret_copy, true);
18129 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_ok(uint64_t o) {
18130 void* o_ptr = untag_ptr(o);
18131 CHECK_ACCESS(o_ptr);
18132 LDKCOption_APIErrorZ o_conv = *(LDKCOption_APIErrorZ*)(o_ptr);
18133 o_conv = COption_APIErrorZ_clone((LDKCOption_APIErrorZ*)untag_ptr(o));
18134 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18135 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_ok(o_conv);
18136 return tag_ptr(ret_conv, true);
18139 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_err"))) TS_CResult_COption_APIErrorZDecodeErrorZ_err(uint64_t e) {
18140 void* e_ptr = untag_ptr(e);
18141 CHECK_ACCESS(e_ptr);
18142 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18143 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18144 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18145 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_err(e_conv);
18146 return tag_ptr(ret_conv, true);
18149 jboolean __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(uint64_t o) {
18150 LDKCResult_COption_APIErrorZDecodeErrorZ* o_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(o);
18151 jboolean ret_conv = CResult_COption_APIErrorZDecodeErrorZ_is_ok(o_conv);
18155 void __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_free"))) TS_CResult_COption_APIErrorZDecodeErrorZ_free(uint64_t _res) {
18156 if (!ptr_is_owned(_res)) return;
18157 void* _res_ptr = untag_ptr(_res);
18158 CHECK_ACCESS(_res_ptr);
18159 LDKCResult_COption_APIErrorZDecodeErrorZ _res_conv = *(LDKCResult_COption_APIErrorZDecodeErrorZ*)(_res_ptr);
18160 FREE(untag_ptr(_res));
18161 CResult_COption_APIErrorZDecodeErrorZ_free(_res_conv);
18164 static inline uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg) {
18165 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18166 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone(arg);
18167 return tag_ptr(ret_conv, true);
18169 int64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(uint64_t arg) {
18170 LDKCResult_COption_APIErrorZDecodeErrorZ* arg_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(arg);
18171 int64_t ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg_conv);
18175 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_clone"))) TS_CResult_COption_APIErrorZDecodeErrorZ_clone(uint64_t orig) {
18176 LDKCResult_COption_APIErrorZDecodeErrorZ* orig_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(orig);
18177 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
18178 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone(orig_conv);
18179 return tag_ptr(ret_conv, true);
18182 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_ok(uint64_t o) {
18183 LDKUntrustedString o_conv;
18184 o_conv.inner = untag_ptr(o);
18185 o_conv.is_owned = ptr_is_owned(o);
18186 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18187 o_conv = UntrustedString_clone(&o_conv);
18188 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18189 *ret_conv = CResult_UntrustedStringDecodeErrorZ_ok(o_conv);
18190 return tag_ptr(ret_conv, true);
18193 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_err"))) TS_CResult_UntrustedStringDecodeErrorZ_err(uint64_t e) {
18194 void* e_ptr = untag_ptr(e);
18195 CHECK_ACCESS(e_ptr);
18196 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18197 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18198 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18199 *ret_conv = CResult_UntrustedStringDecodeErrorZ_err(e_conv);
18200 return tag_ptr(ret_conv, true);
18203 jboolean __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_is_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_is_ok(uint64_t o) {
18204 LDKCResult_UntrustedStringDecodeErrorZ* o_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(o);
18205 jboolean ret_conv = CResult_UntrustedStringDecodeErrorZ_is_ok(o_conv);
18209 void __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_free"))) TS_CResult_UntrustedStringDecodeErrorZ_free(uint64_t _res) {
18210 if (!ptr_is_owned(_res)) return;
18211 void* _res_ptr = untag_ptr(_res);
18212 CHECK_ACCESS(_res_ptr);
18213 LDKCResult_UntrustedStringDecodeErrorZ _res_conv = *(LDKCResult_UntrustedStringDecodeErrorZ*)(_res_ptr);
18214 FREE(untag_ptr(_res));
18215 CResult_UntrustedStringDecodeErrorZ_free(_res_conv);
18218 static inline uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg) {
18219 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18220 *ret_conv = CResult_UntrustedStringDecodeErrorZ_clone(arg);
18221 return tag_ptr(ret_conv, true);
18223 int64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr"))) TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(uint64_t arg) {
18224 LDKCResult_UntrustedStringDecodeErrorZ* arg_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(arg);
18225 int64_t ret_conv = CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg_conv);
18229 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_clone"))) TS_CResult_UntrustedStringDecodeErrorZ_clone(uint64_t orig) {
18230 LDKCResult_UntrustedStringDecodeErrorZ* orig_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(orig);
18231 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
18232 *ret_conv = CResult_UntrustedStringDecodeErrorZ_clone(orig_conv);
18233 return tag_ptr(ret_conv, true);
18236 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_ok"))) TS_CResult_OutPointDecodeErrorZ_ok(uint64_t o) {
18237 LDKOutPoint o_conv;
18238 o_conv.inner = untag_ptr(o);
18239 o_conv.is_owned = ptr_is_owned(o);
18240 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18241 o_conv = OutPoint_clone(&o_conv);
18242 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18243 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
18244 return tag_ptr(ret_conv, true);
18247 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_err"))) TS_CResult_OutPointDecodeErrorZ_err(uint64_t e) {
18248 void* e_ptr = untag_ptr(e);
18249 CHECK_ACCESS(e_ptr);
18250 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18251 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18252 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18253 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
18254 return tag_ptr(ret_conv, true);
18257 jboolean __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_is_ok"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint64_t o) {
18258 LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(o);
18259 jboolean ret_conv = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
18263 void __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_free"))) TS_CResult_OutPointDecodeErrorZ_free(uint64_t _res) {
18264 if (!ptr_is_owned(_res)) return;
18265 void* _res_ptr = untag_ptr(_res);
18266 CHECK_ACCESS(_res_ptr);
18267 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(_res_ptr);
18268 FREE(untag_ptr(_res));
18269 CResult_OutPointDecodeErrorZ_free(_res_conv);
18272 static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
18273 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18274 *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
18275 return tag_ptr(ret_conv, true);
18277 int64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone_ptr"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint64_t arg) {
18278 LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(arg);
18279 int64_t ret_conv = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
18283 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone"))) TS_CResult_OutPointDecodeErrorZ_clone(uint64_t orig) {
18284 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(orig);
18285 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
18286 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
18287 return tag_ptr(ret_conv, true);
18290 uint64_t __attribute__((export_name("TS_COption_TypeZ_some"))) TS_COption_TypeZ_some(uint64_t o) {
18291 void* o_ptr = untag_ptr(o);
18292 CHECK_ACCESS(o_ptr);
18293 LDKType o_conv = *(LDKType*)(o_ptr);
18294 if (o_conv.free == LDKType_JCalls_free) {
18295 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
18296 LDKType_JCalls_cloned(&o_conv);
18298 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18299 *ret_copy = COption_TypeZ_some(o_conv);
18300 uint64_t ret_ref = tag_ptr(ret_copy, true);
18304 uint64_t __attribute__((export_name("TS_COption_TypeZ_none"))) TS_COption_TypeZ_none() {
18305 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18306 *ret_copy = COption_TypeZ_none();
18307 uint64_t ret_ref = tag_ptr(ret_copy, true);
18311 void __attribute__((export_name("TS_COption_TypeZ_free"))) TS_COption_TypeZ_free(uint64_t _res) {
18312 if (!ptr_is_owned(_res)) return;
18313 void* _res_ptr = untag_ptr(_res);
18314 CHECK_ACCESS(_res_ptr);
18315 LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(_res_ptr);
18316 FREE(untag_ptr(_res));
18317 COption_TypeZ_free(_res_conv);
18320 static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
18321 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18322 *ret_copy = COption_TypeZ_clone(arg);
18323 uint64_t ret_ref = tag_ptr(ret_copy, true);
18326 int64_t __attribute__((export_name("TS_COption_TypeZ_clone_ptr"))) TS_COption_TypeZ_clone_ptr(uint64_t arg) {
18327 LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)untag_ptr(arg);
18328 int64_t ret_conv = COption_TypeZ_clone_ptr(arg_conv);
18332 uint64_t __attribute__((export_name("TS_COption_TypeZ_clone"))) TS_COption_TypeZ_clone(uint64_t orig) {
18333 LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)untag_ptr(orig);
18334 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
18335 *ret_copy = COption_TypeZ_clone(orig_conv);
18336 uint64_t ret_ref = tag_ptr(ret_copy, true);
18340 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint64_t o) {
18341 void* o_ptr = untag_ptr(o);
18342 CHECK_ACCESS(o_ptr);
18343 LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(o_ptr);
18344 o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)untag_ptr(o));
18345 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18346 *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv);
18347 return tag_ptr(ret_conv, true);
18350 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_err"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint64_t e) {
18351 void* e_ptr = untag_ptr(e);
18352 CHECK_ACCESS(e_ptr);
18353 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18354 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18355 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18356 *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
18357 return tag_ptr(ret_conv, true);
18360 jboolean __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_is_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint64_t o) {
18361 LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(o);
18362 jboolean ret_conv = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
18366 void __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_free"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint64_t _res) {
18367 if (!ptr_is_owned(_res)) return;
18368 void* _res_ptr = untag_ptr(_res);
18369 CHECK_ACCESS(_res_ptr);
18370 LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(_res_ptr);
18371 FREE(untag_ptr(_res));
18372 CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
18375 static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
18376 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18377 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
18378 return tag_ptr(ret_conv, true);
18380 int64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint64_t arg) {
18381 LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(arg);
18382 int64_t ret_conv = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
18386 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint64_t orig) {
18387 LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(orig);
18388 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
18389 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv);
18390 return tag_ptr(ret_conv, true);
18393 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_ok"))) TS_CResult_PaymentIdPaymentErrorZ_ok(int8_tArray o) {
18394 LDKThirtyTwoBytes o_ref;
18395 CHECK(o->arr_len == 32);
18396 memcpy(o_ref.data, o->elems, 32); FREE(o);
18397 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18398 *ret_conv = CResult_PaymentIdPaymentErrorZ_ok(o_ref);
18399 return tag_ptr(ret_conv, true);
18402 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_err"))) TS_CResult_PaymentIdPaymentErrorZ_err(uint64_t e) {
18403 void* e_ptr = untag_ptr(e);
18404 CHECK_ACCESS(e_ptr);
18405 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
18406 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
18407 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18408 *ret_conv = CResult_PaymentIdPaymentErrorZ_err(e_conv);
18409 return tag_ptr(ret_conv, true);
18412 jboolean __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_is_ok"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint64_t o) {
18413 LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(o);
18414 jboolean ret_conv = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
18418 void __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_free"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint64_t _res) {
18419 if (!ptr_is_owned(_res)) return;
18420 void* _res_ptr = untag_ptr(_res);
18421 CHECK_ACCESS(_res_ptr);
18422 LDKCResult_PaymentIdPaymentErrorZ _res_conv = *(LDKCResult_PaymentIdPaymentErrorZ*)(_res_ptr);
18423 FREE(untag_ptr(_res));
18424 CResult_PaymentIdPaymentErrorZ_free(_res_conv);
18427 static inline uint64_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
18428 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18429 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
18430 return tag_ptr(ret_conv, true);
18432 int64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone_ptr"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint64_t arg) {
18433 LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(arg);
18434 int64_t ret_conv = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
18438 uint64_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint64_t orig) {
18439 LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)untag_ptr(orig);
18440 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
18441 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(orig_conv);
18442 return tag_ptr(ret_conv, true);
18445 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_ok"))) TS_CResult_NonePaymentErrorZ_ok() {
18446 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18447 *ret_conv = CResult_NonePaymentErrorZ_ok();
18448 return tag_ptr(ret_conv, true);
18451 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_err"))) TS_CResult_NonePaymentErrorZ_err(uint64_t e) {
18452 void* e_ptr = untag_ptr(e);
18453 CHECK_ACCESS(e_ptr);
18454 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
18455 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
18456 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18457 *ret_conv = CResult_NonePaymentErrorZ_err(e_conv);
18458 return tag_ptr(ret_conv, true);
18461 jboolean __attribute__((export_name("TS_CResult_NonePaymentErrorZ_is_ok"))) TS_CResult_NonePaymentErrorZ_is_ok(uint64_t o) {
18462 LDKCResult_NonePaymentErrorZ* o_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(o);
18463 jboolean ret_conv = CResult_NonePaymentErrorZ_is_ok(o_conv);
18467 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_free"))) TS_CResult_NonePaymentErrorZ_free(uint64_t _res) {
18468 if (!ptr_is_owned(_res)) return;
18469 void* _res_ptr = untag_ptr(_res);
18470 CHECK_ACCESS(_res_ptr);
18471 LDKCResult_NonePaymentErrorZ _res_conv = *(LDKCResult_NonePaymentErrorZ*)(_res_ptr);
18472 FREE(untag_ptr(_res));
18473 CResult_NonePaymentErrorZ_free(_res_conv);
18476 static inline uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg) {
18477 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18478 *ret_conv = CResult_NonePaymentErrorZ_clone(arg);
18479 return tag_ptr(ret_conv, true);
18481 int64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone_ptr"))) TS_CResult_NonePaymentErrorZ_clone_ptr(uint64_t arg) {
18482 LDKCResult_NonePaymentErrorZ* arg_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(arg);
18483 int64_t ret_conv = CResult_NonePaymentErrorZ_clone_ptr(arg_conv);
18487 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone"))) TS_CResult_NonePaymentErrorZ_clone(uint64_t orig) {
18488 LDKCResult_NonePaymentErrorZ* orig_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(orig);
18489 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
18490 *ret_conv = CResult_NonePaymentErrorZ_clone(orig_conv);
18491 return tag_ptr(ret_conv, true);
18494 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_ok"))) TS_CResult_StringErrorZ_ok(jstring o) {
18495 LDKStr o_conv = str_ref_to_owned_c(o);
18496 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18497 *ret_conv = CResult_StringErrorZ_ok(o_conv);
18498 return tag_ptr(ret_conv, true);
18501 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_err"))) TS_CResult_StringErrorZ_err(uint32_t e) {
18502 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
18503 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18504 *ret_conv = CResult_StringErrorZ_err(e_conv);
18505 return tag_ptr(ret_conv, true);
18508 jboolean __attribute__((export_name("TS_CResult_StringErrorZ_is_ok"))) TS_CResult_StringErrorZ_is_ok(uint64_t o) {
18509 LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)untag_ptr(o);
18510 jboolean ret_conv = CResult_StringErrorZ_is_ok(o_conv);
18514 void __attribute__((export_name("TS_CResult_StringErrorZ_free"))) TS_CResult_StringErrorZ_free(uint64_t _res) {
18515 if (!ptr_is_owned(_res)) return;
18516 void* _res_ptr = untag_ptr(_res);
18517 CHECK_ACCESS(_res_ptr);
18518 LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(_res_ptr);
18519 FREE(untag_ptr(_res));
18520 CResult_StringErrorZ_free(_res_conv);
18523 static inline uint64_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg) {
18524 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18525 *ret_conv = CResult_StringErrorZ_clone(arg);
18526 return tag_ptr(ret_conv, true);
18528 int64_t __attribute__((export_name("TS_CResult_StringErrorZ_clone_ptr"))) TS_CResult_StringErrorZ_clone_ptr(uint64_t arg) {
18529 LDKCResult_StringErrorZ* arg_conv = (LDKCResult_StringErrorZ*)untag_ptr(arg);
18530 int64_t ret_conv = CResult_StringErrorZ_clone_ptr(arg_conv);
18534 uint64_t __attribute__((export_name("TS_CResult_StringErrorZ_clone"))) TS_CResult_StringErrorZ_clone(uint64_t orig) {
18535 LDKCResult_StringErrorZ* orig_conv = (LDKCResult_StringErrorZ*)untag_ptr(orig);
18536 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
18537 *ret_conv = CResult_StringErrorZ_clone(orig_conv);
18538 return tag_ptr(ret_conv, true);
18541 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint64_t o) {
18542 LDKChannelMonitorUpdate o_conv;
18543 o_conv.inner = untag_ptr(o);
18544 o_conv.is_owned = ptr_is_owned(o);
18545 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18546 o_conv = ChannelMonitorUpdate_clone(&o_conv);
18547 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18548 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
18549 return tag_ptr(ret_conv, true);
18552 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint64_t e) {
18553 void* e_ptr = untag_ptr(e);
18554 CHECK_ACCESS(e_ptr);
18555 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18556 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18557 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18558 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
18559 return tag_ptr(ret_conv, true);
18562 jboolean __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint64_t o) {
18563 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(o);
18564 jboolean ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
18568 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint64_t _res) {
18569 if (!ptr_is_owned(_res)) return;
18570 void* _res_ptr = untag_ptr(_res);
18571 CHECK_ACCESS(_res_ptr);
18572 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(_res_ptr);
18573 FREE(untag_ptr(_res));
18574 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
18577 static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
18578 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18579 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
18580 return tag_ptr(ret_conv, true);
18582 int64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
18583 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(arg);
18584 int64_t ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
18588 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint64_t orig) {
18589 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(orig);
18590 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
18591 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
18592 return tag_ptr(ret_conv, true);
18595 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_some"))) TS_COption_MonitorEventZ_some(uint64_t o) {
18596 void* o_ptr = untag_ptr(o);
18597 CHECK_ACCESS(o_ptr);
18598 LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
18599 o_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(o));
18600 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18601 *ret_copy = COption_MonitorEventZ_some(o_conv);
18602 uint64_t ret_ref = tag_ptr(ret_copy, true);
18606 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_none"))) TS_COption_MonitorEventZ_none() {
18607 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18608 *ret_copy = COption_MonitorEventZ_none();
18609 uint64_t ret_ref = tag_ptr(ret_copy, true);
18613 void __attribute__((export_name("TS_COption_MonitorEventZ_free"))) TS_COption_MonitorEventZ_free(uint64_t _res) {
18614 if (!ptr_is_owned(_res)) return;
18615 void* _res_ptr = untag_ptr(_res);
18616 CHECK_ACCESS(_res_ptr);
18617 LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
18618 FREE(untag_ptr(_res));
18619 COption_MonitorEventZ_free(_res_conv);
18622 static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
18623 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18624 *ret_copy = COption_MonitorEventZ_clone(arg);
18625 uint64_t ret_ref = tag_ptr(ret_copy, true);
18628 int64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone_ptr"))) TS_COption_MonitorEventZ_clone_ptr(uint64_t arg) {
18629 LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)untag_ptr(arg);
18630 int64_t ret_conv = COption_MonitorEventZ_clone_ptr(arg_conv);
18634 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone"))) TS_COption_MonitorEventZ_clone(uint64_t orig) {
18635 LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)untag_ptr(orig);
18636 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
18637 *ret_copy = COption_MonitorEventZ_clone(orig_conv);
18638 uint64_t ret_ref = tag_ptr(ret_copy, true);
18642 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint64_t o) {
18643 void* o_ptr = untag_ptr(o);
18644 CHECK_ACCESS(o_ptr);
18645 LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
18646 o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)untag_ptr(o));
18647 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18648 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
18649 return tag_ptr(ret_conv, true);
18652 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint64_t e) {
18653 void* e_ptr = untag_ptr(e);
18654 CHECK_ACCESS(e_ptr);
18655 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18656 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18657 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18658 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
18659 return tag_ptr(ret_conv, true);
18662 jboolean __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint64_t o) {
18663 LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(o);
18664 jboolean ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
18668 void __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_free"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint64_t _res) {
18669 if (!ptr_is_owned(_res)) return;
18670 void* _res_ptr = untag_ptr(_res);
18671 CHECK_ACCESS(_res_ptr);
18672 LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
18673 FREE(untag_ptr(_res));
18674 CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
18677 static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
18678 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18679 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
18680 return tag_ptr(ret_conv, true);
18682 int64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint64_t arg) {
18683 LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(arg);
18684 int64_t ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
18688 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint64_t orig) {
18689 LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(orig);
18690 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
18691 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
18692 return tag_ptr(ret_conv, true);
18695 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint64_t o) {
18696 LDKHTLCUpdate o_conv;
18697 o_conv.inner = untag_ptr(o);
18698 o_conv.is_owned = ptr_is_owned(o);
18699 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18700 o_conv = HTLCUpdate_clone(&o_conv);
18701 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18702 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
18703 return tag_ptr(ret_conv, true);
18706 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint64_t e) {
18707 void* e_ptr = untag_ptr(e);
18708 CHECK_ACCESS(e_ptr);
18709 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18710 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18711 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18712 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
18713 return tag_ptr(ret_conv, true);
18716 jboolean __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_is_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint64_t o) {
18717 LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(o);
18718 jboolean ret_conv = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
18722 void __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_free"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint64_t _res) {
18723 if (!ptr_is_owned(_res)) return;
18724 void* _res_ptr = untag_ptr(_res);
18725 CHECK_ACCESS(_res_ptr);
18726 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(_res_ptr);
18727 FREE(untag_ptr(_res));
18728 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
18731 static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
18732 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18733 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
18734 return tag_ptr(ret_conv, true);
18736 int64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
18737 LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(arg);
18738 int64_t ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
18742 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint64_t orig) {
18743 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(orig);
18744 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
18745 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
18746 return tag_ptr(ret_conv, true);
18749 static inline uint64_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
18750 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
18751 *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
18752 return tag_ptr(ret_conv, true);
18754 int64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone_ptr"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint64_t arg) {
18755 LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(arg);
18756 int64_t ret_conv = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
18760 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone"))) TS_C2Tuple_OutPointScriptZ_clone(uint64_t orig) {
18761 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)untag_ptr(orig);
18762 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
18763 *ret_conv = C2Tuple_OutPointScriptZ_clone(orig_conv);
18764 return tag_ptr(ret_conv, true);
18767 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_new"))) TS_C2Tuple_OutPointScriptZ_new(uint64_t a, int8_tArray b) {
18768 LDKOutPoint a_conv;
18769 a_conv.inner = untag_ptr(a);
18770 a_conv.is_owned = ptr_is_owned(a);
18771 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
18772 a_conv = OutPoint_clone(&a_conv);
18774 b_ref.datalen = b->arr_len;
18775 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
18776 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
18777 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
18778 *ret_conv = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
18779 return tag_ptr(ret_conv, true);
18782 void __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_free"))) TS_C2Tuple_OutPointScriptZ_free(uint64_t _res) {
18783 if (!ptr_is_owned(_res)) return;
18784 void* _res_ptr = untag_ptr(_res);
18785 CHECK_ACCESS(_res_ptr);
18786 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(_res_ptr);
18787 FREE(untag_ptr(_res));
18788 C2Tuple_OutPointScriptZ_free(_res_conv);
18791 static inline uint64_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
18792 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18793 *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
18794 return tag_ptr(ret_conv, true);
18796 int64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone_ptr"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint64_t arg) {
18797 LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(arg);
18798 int64_t ret_conv = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
18802 uint64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone"))) TS_C2Tuple_u32ScriptZ_clone(uint64_t orig) {
18803 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)untag_ptr(orig);
18804 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18805 *ret_conv = C2Tuple_u32ScriptZ_clone(orig_conv);
18806 return tag_ptr(ret_conv, true);
18809 uint64_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_new"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
18811 b_ref.datalen = b->arr_len;
18812 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
18813 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
18814 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
18815 *ret_conv = C2Tuple_u32ScriptZ_new(a, b_ref);
18816 return tag_ptr(ret_conv, true);
18819 void __attribute__((export_name("TS_C2Tuple_u32ScriptZ_free"))) TS_C2Tuple_u32ScriptZ_free(uint64_t _res) {
18820 if (!ptr_is_owned(_res)) return;
18821 void* _res_ptr = untag_ptr(_res);
18822 CHECK_ACCESS(_res_ptr);
18823 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_ptr);
18824 FREE(untag_ptr(_res));
18825 C2Tuple_u32ScriptZ_free(_res_conv);
18828 void __attribute__((export_name("TS_CVec_C2Tuple_u32ScriptZZ_free"))) TS_CVec_C2Tuple_u32ScriptZZ_free(uint64_tArray _res) {
18829 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
18830 _res_constr.datalen = _res->arr_len;
18831 if (_res_constr.datalen > 0)
18832 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
18834 _res_constr.data = NULL;
18835 uint64_t* _res_vals = _res->elems;
18836 for (size_t v = 0; v < _res_constr.datalen; v++) {
18837 uint64_t _res_conv_21 = _res_vals[v];
18838 void* _res_conv_21_ptr = untag_ptr(_res_conv_21);
18839 CHECK_ACCESS(_res_conv_21_ptr);
18840 LDKC2Tuple_u32ScriptZ _res_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_conv_21_ptr);
18841 FREE(untag_ptr(_res_conv_21));
18842 _res_constr.data[v] = _res_conv_21_conv;
18845 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
18848 static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
18849 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18850 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
18851 return tag_ptr(ret_conv, true);
18853 int64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint64_t arg) {
18854 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(arg);
18855 int64_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
18859 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint64_t orig) {
18860 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)untag_ptr(orig);
18861 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18862 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
18863 return tag_ptr(ret_conv, true);
18866 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint64_tArray b) {
18867 LDKThirtyTwoBytes a_ref;
18868 CHECK(a->arr_len == 32);
18869 memcpy(a_ref.data, a->elems, 32); FREE(a);
18870 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
18871 b_constr.datalen = b->arr_len;
18872 if (b_constr.datalen > 0)
18873 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
18875 b_constr.data = NULL;
18876 uint64_t* b_vals = b->elems;
18877 for (size_t v = 0; v < b_constr.datalen; v++) {
18878 uint64_t b_conv_21 = b_vals[v];
18879 void* b_conv_21_ptr = untag_ptr(b_conv_21);
18880 CHECK_ACCESS(b_conv_21_ptr);
18881 LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(b_conv_21_ptr);
18882 b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)untag_ptr(b_conv_21));
18883 b_constr.data[v] = b_conv_21_conv;
18886 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
18887 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
18888 return tag_ptr(ret_conv, true);
18891 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint64_t _res) {
18892 if (!ptr_is_owned(_res)) return;
18893 void* _res_ptr = untag_ptr(_res);
18894 CHECK_ACCESS(_res_ptr);
18895 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_ptr);
18896 FREE(untag_ptr(_res));
18897 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
18900 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(uint64_tArray _res) {
18901 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
18902 _res_constr.datalen = _res->arr_len;
18903 if (_res_constr.datalen > 0)
18904 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
18906 _res_constr.data = NULL;
18907 uint64_t* _res_vals = _res->elems;
18908 for (size_t o = 0; o < _res_constr.datalen; o++) {
18909 uint64_t _res_conv_40 = _res_vals[o];
18910 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
18911 CHECK_ACCESS(_res_conv_40_ptr);
18912 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_40_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_conv_40_ptr);
18913 FREE(untag_ptr(_res_conv_40));
18914 _res_constr.data[o] = _res_conv_40_conv;
18917 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
18920 void __attribute__((export_name("TS_CVec_EventZ_free"))) TS_CVec_EventZ_free(uint64_tArray _res) {
18921 LDKCVec_EventZ _res_constr;
18922 _res_constr.datalen = _res->arr_len;
18923 if (_res_constr.datalen > 0)
18924 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
18926 _res_constr.data = NULL;
18927 uint64_t* _res_vals = _res->elems;
18928 for (size_t h = 0; h < _res_constr.datalen; h++) {
18929 uint64_t _res_conv_7 = _res_vals[h];
18930 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
18931 CHECK_ACCESS(_res_conv_7_ptr);
18932 LDKEvent _res_conv_7_conv = *(LDKEvent*)(_res_conv_7_ptr);
18933 FREE(untag_ptr(_res_conv_7));
18934 _res_constr.data[h] = _res_conv_7_conv;
18937 CVec_EventZ_free(_res_constr);
18940 void __attribute__((export_name("TS_CVec_TransactionZ_free"))) TS_CVec_TransactionZ_free(ptrArray _res) {
18941 LDKCVec_TransactionZ _res_constr;
18942 _res_constr.datalen = _res->arr_len;
18943 if (_res_constr.datalen > 0)
18944 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
18946 _res_constr.data = NULL;
18947 int8_tArray* _res_vals = (void*) _res->elems;
18948 for (size_t m = 0; m < _res_constr.datalen; m++) {
18949 int8_tArray _res_conv_12 = _res_vals[m];
18950 LDKTransaction _res_conv_12_ref;
18951 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
18952 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
18953 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
18954 _res_conv_12_ref.data_is_owned = true;
18955 _res_constr.data[m] = _res_conv_12_ref;
18958 CVec_TransactionZ_free(_res_constr);
18961 static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
18962 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18963 *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
18964 return tag_ptr(ret_conv, true);
18966 int64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone_ptr"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint64_t arg) {
18967 LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(arg);
18968 int64_t ret_conv = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
18972 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone"))) TS_C2Tuple_u32TxOutZ_clone(uint64_t orig) {
18973 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(orig);
18974 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18975 *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv);
18976 return tag_ptr(ret_conv, true);
18979 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_new"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint64_t b) {
18980 void* b_ptr = untag_ptr(b);
18981 CHECK_ACCESS(b_ptr);
18982 LDKTxOut b_conv = *(LDKTxOut*)(b_ptr);
18983 b_conv = TxOut_clone((LDKTxOut*)untag_ptr(b));
18984 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18985 *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv);
18986 return tag_ptr(ret_conv, true);
18989 void __attribute__((export_name("TS_C2Tuple_u32TxOutZ_free"))) TS_C2Tuple_u32TxOutZ_free(uint64_t _res) {
18990 if (!ptr_is_owned(_res)) return;
18991 void* _res_ptr = untag_ptr(_res);
18992 CHECK_ACCESS(_res_ptr);
18993 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_ptr);
18994 FREE(untag_ptr(_res));
18995 C2Tuple_u32TxOutZ_free(_res_conv);
18998 void __attribute__((export_name("TS_CVec_C2Tuple_u32TxOutZZ_free"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint64_tArray _res) {
18999 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
19000 _res_constr.datalen = _res->arr_len;
19001 if (_res_constr.datalen > 0)
19002 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
19004 _res_constr.data = NULL;
19005 uint64_t* _res_vals = _res->elems;
19006 for (size_t u = 0; u < _res_constr.datalen; u++) {
19007 uint64_t _res_conv_20 = _res_vals[u];
19008 void* _res_conv_20_ptr = untag_ptr(_res_conv_20);
19009 CHECK_ACCESS(_res_conv_20_ptr);
19010 LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_conv_20_ptr);
19011 FREE(untag_ptr(_res_conv_20));
19012 _res_constr.data[u] = _res_conv_20_conv;
19015 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
19018 static inline uint64_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
19019 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
19020 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
19021 return tag_ptr(ret_conv, true);
19023 int64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint64_t arg) {
19024 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(arg);
19025 int64_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
19029 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint64_t orig) {
19030 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(orig);
19031 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
19032 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
19033 return tag_ptr(ret_conv, true);
19036 uint64_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint64_tArray b) {
19037 LDKThirtyTwoBytes a_ref;
19038 CHECK(a->arr_len == 32);
19039 memcpy(a_ref.data, a->elems, 32); FREE(a);
19040 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
19041 b_constr.datalen = b->arr_len;
19042 if (b_constr.datalen > 0)
19043 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
19045 b_constr.data = NULL;
19046 uint64_t* b_vals = b->elems;
19047 for (size_t u = 0; u < b_constr.datalen; u++) {
19048 uint64_t b_conv_20 = b_vals[u];
19049 void* b_conv_20_ptr = untag_ptr(b_conv_20);
19050 CHECK_ACCESS(b_conv_20_ptr);
19051 LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(b_conv_20_ptr);
19052 b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)untag_ptr(b_conv_20));
19053 b_constr.data[u] = b_conv_20_conv;
19056 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
19057 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
19058 return tag_ptr(ret_conv, true);
19061 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint64_t _res) {
19062 if (!ptr_is_owned(_res)) return;
19063 void* _res_ptr = untag_ptr(_res);
19064 CHECK_ACCESS(_res_ptr);
19065 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_ptr);
19066 FREE(untag_ptr(_res));
19067 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
19070 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(uint64_tArray _res) {
19071 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
19072 _res_constr.datalen = _res->arr_len;
19073 if (_res_constr.datalen > 0)
19074 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
19076 _res_constr.data = NULL;
19077 uint64_t* _res_vals = _res->elems;
19078 for (size_t n = 0; n < _res_constr.datalen; n++) {
19079 uint64_t _res_conv_39 = _res_vals[n];
19080 void* _res_conv_39_ptr = untag_ptr(_res_conv_39);
19081 CHECK_ACCESS(_res_conv_39_ptr);
19082 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_39_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_conv_39_ptr);
19083 FREE(untag_ptr(_res_conv_39));
19084 _res_constr.data[n] = _res_conv_39_conv;
19087 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
19090 void __attribute__((export_name("TS_CVec_BalanceZ_free"))) TS_CVec_BalanceZ_free(uint64_tArray _res) {
19091 LDKCVec_BalanceZ _res_constr;
19092 _res_constr.datalen = _res->arr_len;
19093 if (_res_constr.datalen > 0)
19094 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements");
19096 _res_constr.data = NULL;
19097 uint64_t* _res_vals = _res->elems;
19098 for (size_t j = 0; j < _res_constr.datalen; j++) {
19099 uint64_t _res_conv_9 = _res_vals[j];
19100 void* _res_conv_9_ptr = untag_ptr(_res_conv_9);
19101 CHECK_ACCESS(_res_conv_9_ptr);
19102 LDKBalance _res_conv_9_conv = *(LDKBalance*)(_res_conv_9_ptr);
19103 FREE(untag_ptr(_res_conv_9));
19104 _res_constr.data[j] = _res_conv_9_conv;
19107 CVec_BalanceZ_free(_res_constr);
19110 static inline uint64_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
19111 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
19112 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
19113 return tag_ptr(ret_conv, true);
19115 int64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint64_t arg) {
19116 LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(arg);
19117 int64_t ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
19121 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint64_t orig) {
19122 LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(orig);
19123 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
19124 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(orig_conv);
19125 return tag_ptr(ret_conv, true);
19128 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_new"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint64_t b) {
19129 LDKThirtyTwoBytes a_ref;
19130 CHECK(a->arr_len == 32);
19131 memcpy(a_ref.data, a->elems, 32); FREE(a);
19132 LDKChannelMonitor b_conv;
19133 b_conv.inner = untag_ptr(b);
19134 b_conv.is_owned = ptr_is_owned(b);
19135 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
19136 b_conv = ChannelMonitor_clone(&b_conv);
19137 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
19138 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
19139 return tag_ptr(ret_conv, true);
19142 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_free"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint64_t _res) {
19143 if (!ptr_is_owned(_res)) return;
19144 void* _res_ptr = untag_ptr(_res);
19145 CHECK_ACCESS(_res_ptr);
19146 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(_res_ptr);
19147 FREE(untag_ptr(_res));
19148 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
19151 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint64_t o) {
19152 void* o_ptr = untag_ptr(o);
19153 CHECK_ACCESS(o_ptr);
19154 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(o_ptr);
19155 o_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)untag_ptr(o));
19156 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19157 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
19158 return tag_ptr(ret_conv, true);
19161 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(uint64_t e) {
19162 void* e_ptr = untag_ptr(e);
19163 CHECK_ACCESS(e_ptr);
19164 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19165 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19166 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19167 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
19168 return tag_ptr(ret_conv, true);
19171 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint64_t o) {
19172 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(o);
19173 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
19177 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint64_t _res) {
19178 if (!ptr_is_owned(_res)) return;
19179 void* _res_ptr = untag_ptr(_res);
19180 CHECK_ACCESS(_res_ptr);
19181 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(_res_ptr);
19182 FREE(untag_ptr(_res));
19183 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
19186 static inline uint64_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
19187 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19188 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
19189 return tag_ptr(ret_conv, true);
19191 int64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint64_t arg) {
19192 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(arg);
19193 int64_t ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
19197 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint64_t orig) {
19198 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)untag_ptr(orig);
19199 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
19200 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig_conv);
19201 return tag_ptr(ret_conv, true);
19204 static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
19205 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
19206 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
19207 return tag_ptr(ret_conv, true);
19209 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone_ptr"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint64_t arg) {
19210 LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(arg);
19211 int64_t ret_conv = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
19215 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint64_t orig) {
19216 LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(orig);
19217 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
19218 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv);
19219 return tag_ptr(ret_conv, true);
19222 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_new"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint64_t b) {
19223 LDKPublicKey a_ref;
19224 CHECK(a->arr_len == 33);
19225 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
19226 void* b_ptr = untag_ptr(b);
19227 CHECK_ACCESS(b_ptr);
19228 LDKType b_conv = *(LDKType*)(b_ptr);
19229 if (b_conv.free == LDKType_JCalls_free) {
19230 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19231 LDKType_JCalls_cloned(&b_conv);
19233 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
19234 *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv);
19235 return tag_ptr(ret_conv, true);
19238 void __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_free"))) TS_C2Tuple_PublicKeyTypeZ_free(uint64_t _res) {
19239 if (!ptr_is_owned(_res)) return;
19240 void* _res_ptr = untag_ptr(_res);
19241 CHECK_ACCESS(_res_ptr);
19242 LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_ptr);
19243 FREE(untag_ptr(_res));
19244 C2Tuple_PublicKeyTypeZ_free(_res_conv);
19247 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyTypeZZ_free"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint64_tArray _res) {
19248 LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr;
19249 _res_constr.datalen = _res->arr_len;
19250 if (_res_constr.datalen > 0)
19251 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
19253 _res_constr.data = NULL;
19254 uint64_t* _res_vals = _res->elems;
19255 for (size_t z = 0; z < _res_constr.datalen; z++) {
19256 uint64_t _res_conv_25 = _res_vals[z];
19257 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
19258 CHECK_ACCESS(_res_conv_25_ptr);
19259 LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_conv_25_ptr);
19260 FREE(untag_ptr(_res_conv_25));
19261 _res_constr.data[z] = _res_conv_25_conv;
19264 CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr);
19267 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_some"))) TS_COption_CustomOnionMessageContentsZ_some(uint64_t o) {
19268 void* o_ptr = untag_ptr(o);
19269 CHECK_ACCESS(o_ptr);
19270 LDKCustomOnionMessageContents o_conv = *(LDKCustomOnionMessageContents*)(o_ptr);
19271 if (o_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
19272 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
19273 LDKCustomOnionMessageContents_JCalls_cloned(&o_conv);
19275 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19276 *ret_copy = COption_CustomOnionMessageContentsZ_some(o_conv);
19277 uint64_t ret_ref = tag_ptr(ret_copy, true);
19281 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_none"))) TS_COption_CustomOnionMessageContentsZ_none() {
19282 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19283 *ret_copy = COption_CustomOnionMessageContentsZ_none();
19284 uint64_t ret_ref = tag_ptr(ret_copy, true);
19288 void __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_free"))) TS_COption_CustomOnionMessageContentsZ_free(uint64_t _res) {
19289 if (!ptr_is_owned(_res)) return;
19290 void* _res_ptr = untag_ptr(_res);
19291 CHECK_ACCESS(_res_ptr);
19292 LDKCOption_CustomOnionMessageContentsZ _res_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(_res_ptr);
19293 FREE(untag_ptr(_res));
19294 COption_CustomOnionMessageContentsZ_free(_res_conv);
19297 static inline uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg) {
19298 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19299 *ret_copy = COption_CustomOnionMessageContentsZ_clone(arg);
19300 uint64_t ret_ref = tag_ptr(ret_copy, true);
19303 int64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone_ptr"))) TS_COption_CustomOnionMessageContentsZ_clone_ptr(uint64_t arg) {
19304 LDKCOption_CustomOnionMessageContentsZ* arg_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(arg);
19305 int64_t ret_conv = COption_CustomOnionMessageContentsZ_clone_ptr(arg_conv);
19309 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone"))) TS_COption_CustomOnionMessageContentsZ_clone(uint64_t orig) {
19310 LDKCOption_CustomOnionMessageContentsZ* orig_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(orig);
19311 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
19312 *ret_copy = COption_CustomOnionMessageContentsZ_clone(orig_conv);
19313 uint64_t ret_ref = tag_ptr(ret_copy, true);
19317 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(uint64_t o) {
19318 void* o_ptr = untag_ptr(o);
19319 CHECK_ACCESS(o_ptr);
19320 LDKCOption_CustomOnionMessageContentsZ o_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(o_ptr);
19321 o_conv = COption_CustomOnionMessageContentsZ_clone((LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(o));
19322 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19323 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o_conv);
19324 return tag_ptr(ret_conv, true);
19327 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(uint64_t e) {
19328 void* e_ptr = untag_ptr(e);
19329 CHECK_ACCESS(e_ptr);
19330 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19331 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19332 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19333 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e_conv);
19334 return tag_ptr(ret_conv, true);
19337 jboolean __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(uint64_t o) {
19338 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* o_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(o);
19339 jboolean ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o_conv);
19343 void __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(uint64_t _res) {
19344 if (!ptr_is_owned(_res)) return;
19345 void* _res_ptr = untag_ptr(_res);
19346 CHECK_ACCESS(_res_ptr);
19347 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(_res_ptr);
19348 FREE(untag_ptr(_res));
19349 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res_conv);
19352 static inline uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg) {
19353 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19354 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(arg);
19355 return tag_ptr(ret_conv, true);
19357 int64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(uint64_t arg) {
19358 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* arg_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(arg);
19359 int64_t ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg_conv);
19363 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(uint64_t orig) {
19364 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* orig_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(orig);
19365 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
19366 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig_conv);
19367 return tag_ptr(ret_conv, true);
19370 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_some"))) TS_COption_NetAddressZ_some(uint64_t o) {
19371 void* o_ptr = untag_ptr(o);
19372 CHECK_ACCESS(o_ptr);
19373 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
19374 o_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o));
19375 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19376 *ret_copy = COption_NetAddressZ_some(o_conv);
19377 uint64_t ret_ref = tag_ptr(ret_copy, true);
19381 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_none"))) TS_COption_NetAddressZ_none() {
19382 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19383 *ret_copy = COption_NetAddressZ_none();
19384 uint64_t ret_ref = tag_ptr(ret_copy, true);
19388 void __attribute__((export_name("TS_COption_NetAddressZ_free"))) TS_COption_NetAddressZ_free(uint64_t _res) {
19389 if (!ptr_is_owned(_res)) return;
19390 void* _res_ptr = untag_ptr(_res);
19391 CHECK_ACCESS(_res_ptr);
19392 LDKCOption_NetAddressZ _res_conv = *(LDKCOption_NetAddressZ*)(_res_ptr);
19393 FREE(untag_ptr(_res));
19394 COption_NetAddressZ_free(_res_conv);
19397 static inline uint64_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg) {
19398 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19399 *ret_copy = COption_NetAddressZ_clone(arg);
19400 uint64_t ret_ref = tag_ptr(ret_copy, true);
19403 int64_t __attribute__((export_name("TS_COption_NetAddressZ_clone_ptr"))) TS_COption_NetAddressZ_clone_ptr(uint64_t arg) {
19404 LDKCOption_NetAddressZ* arg_conv = (LDKCOption_NetAddressZ*)untag_ptr(arg);
19405 int64_t ret_conv = COption_NetAddressZ_clone_ptr(arg_conv);
19409 uint64_t __attribute__((export_name("TS_COption_NetAddressZ_clone"))) TS_COption_NetAddressZ_clone(uint64_t orig) {
19410 LDKCOption_NetAddressZ* orig_conv = (LDKCOption_NetAddressZ*)untag_ptr(orig);
19411 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
19412 *ret_copy = COption_NetAddressZ_clone(orig_conv);
19413 uint64_t ret_ref = tag_ptr(ret_copy, true);
19417 static inline uint64_t C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_NetAddressZZ *NONNULL_PTR arg) {
19418 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
19419 *ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_clone(arg);
19420 return tag_ptr(ret_conv, true);
19422 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(uint64_t arg) {
19423 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* arg_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(arg);
19424 int64_t ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_clone_ptr(arg_conv);
19428 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_clone(uint64_t orig) {
19429 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* orig_conv = (LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)untag_ptr(orig);
19430 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
19431 *ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_clone(orig_conv);
19432 return tag_ptr(ret_conv, true);
19435 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_new"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_new(int8_tArray a, uint64_t b) {
19436 LDKPublicKey a_ref;
19437 CHECK(a->arr_len == 33);
19438 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
19439 void* b_ptr = untag_ptr(b);
19440 CHECK_ACCESS(b_ptr);
19441 LDKCOption_NetAddressZ b_conv = *(LDKCOption_NetAddressZ*)(b_ptr);
19442 b_conv = COption_NetAddressZ_clone((LDKCOption_NetAddressZ*)untag_ptr(b));
19443 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
19444 *ret_conv = C2Tuple_PublicKeyCOption_NetAddressZZ_new(a_ref, b_conv);
19445 return tag_ptr(ret_conv, true);
19448 void __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_NetAddressZZ_free"))) TS_C2Tuple_PublicKeyCOption_NetAddressZZ_free(uint64_t _res) {
19449 if (!ptr_is_owned(_res)) return;
19450 void* _res_ptr = untag_ptr(_res);
19451 CHECK_ACCESS(_res_ptr);
19452 LDKC2Tuple_PublicKeyCOption_NetAddressZZ _res_conv = *(LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)(_res_ptr);
19453 FREE(untag_ptr(_res));
19454 C2Tuple_PublicKeyCOption_NetAddressZZ_free(_res_conv);
19457 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free"))) TS_CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(uint64_tArray _res) {
19458 LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ _res_constr;
19459 _res_constr.datalen = _res->arr_len;
19460 if (_res_constr.datalen > 0)
19461 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ Elements");
19463 _res_constr.data = NULL;
19464 uint64_t* _res_vals = _res->elems;
19465 for (size_t o = 0; o < _res_constr.datalen; o++) {
19466 uint64_t _res_conv_40 = _res_vals[o];
19467 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
19468 CHECK_ACCESS(_res_conv_40_ptr);
19469 LDKC2Tuple_PublicKeyCOption_NetAddressZZ _res_conv_40_conv = *(LDKC2Tuple_PublicKeyCOption_NetAddressZZ*)(_res_conv_40_ptr);
19470 FREE(untag_ptr(_res_conv_40));
19471 _res_constr.data[o] = _res_conv_40_conv;
19474 CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ_free(_res_constr);
19477 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
19479 o_ref.datalen = o->arr_len;
19480 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
19481 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
19482 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19483 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
19484 return tag_ptr(ret_conv, true);
19487 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint64_t e) {
19488 LDKPeerHandleError e_conv;
19489 e_conv.inner = untag_ptr(e);
19490 e_conv.is_owned = ptr_is_owned(e);
19491 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19492 e_conv = PeerHandleError_clone(&e_conv);
19493 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19494 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
19495 return tag_ptr(ret_conv, true);
19498 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint64_t o) {
19499 LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(o);
19500 jboolean ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
19504 void __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_free"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint64_t _res) {
19505 if (!ptr_is_owned(_res)) return;
19506 void* _res_ptr = untag_ptr(_res);
19507 CHECK_ACCESS(_res_ptr);
19508 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(_res_ptr);
19509 FREE(untag_ptr(_res));
19510 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
19513 static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
19514 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19515 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
19516 return tag_ptr(ret_conv, true);
19518 int64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint64_t arg) {
19519 LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(arg);
19520 int64_t ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
19524 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint64_t orig) {
19525 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(orig);
19526 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
19527 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
19528 return tag_ptr(ret_conv, true);
19531 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_ok"))) TS_CResult_NonePeerHandleErrorZ_ok() {
19532 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19533 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
19534 return tag_ptr(ret_conv, true);
19537 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_err"))) TS_CResult_NonePeerHandleErrorZ_err(uint64_t e) {
19538 LDKPeerHandleError e_conv;
19539 e_conv.inner = untag_ptr(e);
19540 e_conv.is_owned = ptr_is_owned(e);
19541 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19542 e_conv = PeerHandleError_clone(&e_conv);
19543 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19544 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
19545 return tag_ptr(ret_conv, true);
19548 jboolean __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_is_ok"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint64_t o) {
19549 LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(o);
19550 jboolean ret_conv = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
19554 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_free"))) TS_CResult_NonePeerHandleErrorZ_free(uint64_t _res) {
19555 if (!ptr_is_owned(_res)) return;
19556 void* _res_ptr = untag_ptr(_res);
19557 CHECK_ACCESS(_res_ptr);
19558 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(_res_ptr);
19559 FREE(untag_ptr(_res));
19560 CResult_NonePeerHandleErrorZ_free(_res_conv);
19563 static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
19564 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19565 *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
19566 return tag_ptr(ret_conv, true);
19568 int64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone_ptr"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint64_t arg) {
19569 LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(arg);
19570 int64_t ret_conv = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
19574 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone"))) TS_CResult_NonePeerHandleErrorZ_clone(uint64_t orig) {
19575 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(orig);
19576 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
19577 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
19578 return tag_ptr(ret_conv, true);
19581 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_ok"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
19582 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19583 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
19584 return tag_ptr(ret_conv, true);
19587 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_err"))) TS_CResult_boolPeerHandleErrorZ_err(uint64_t e) {
19588 LDKPeerHandleError e_conv;
19589 e_conv.inner = untag_ptr(e);
19590 e_conv.is_owned = ptr_is_owned(e);
19591 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19592 e_conv = PeerHandleError_clone(&e_conv);
19593 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19594 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
19595 return tag_ptr(ret_conv, true);
19598 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_is_ok"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint64_t o) {
19599 LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(o);
19600 jboolean ret_conv = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
19604 void __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_free"))) TS_CResult_boolPeerHandleErrorZ_free(uint64_t _res) {
19605 if (!ptr_is_owned(_res)) return;
19606 void* _res_ptr = untag_ptr(_res);
19607 CHECK_ACCESS(_res_ptr);
19608 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(_res_ptr);
19609 FREE(untag_ptr(_res));
19610 CResult_boolPeerHandleErrorZ_free(_res_conv);
19613 static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
19614 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19615 *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
19616 return tag_ptr(ret_conv, true);
19618 int64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone_ptr"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint64_t arg) {
19619 LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(arg);
19620 int64_t ret_conv = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
19624 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone"))) TS_CResult_boolPeerHandleErrorZ_clone(uint64_t orig) {
19625 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(orig);
19626 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
19627 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
19628 return tag_ptr(ret_conv, true);
19631 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_ok(uint64_t o) {
19632 void* o_ptr = untag_ptr(o);
19633 CHECK_ACCESS(o_ptr);
19634 LDKTxOut o_conv = *(LDKTxOut*)(o_ptr);
19635 o_conv = TxOut_clone((LDKTxOut*)untag_ptr(o));
19636 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19637 *ret_conv = CResult_TxOutUtxoLookupErrorZ_ok(o_conv);
19638 return tag_ptr(ret_conv, true);
19641 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_err"))) TS_CResult_TxOutUtxoLookupErrorZ_err(uint32_t e) {
19642 LDKUtxoLookupError e_conv = LDKUtxoLookupError_from_js(e);
19643 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19644 *ret_conv = CResult_TxOutUtxoLookupErrorZ_err(e_conv);
19645 return tag_ptr(ret_conv, true);
19648 jboolean __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_is_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_is_ok(uint64_t o) {
19649 LDKCResult_TxOutUtxoLookupErrorZ* o_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(o);
19650 jboolean ret_conv = CResult_TxOutUtxoLookupErrorZ_is_ok(o_conv);
19654 void __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_free"))) TS_CResult_TxOutUtxoLookupErrorZ_free(uint64_t _res) {
19655 if (!ptr_is_owned(_res)) return;
19656 void* _res_ptr = untag_ptr(_res);
19657 CHECK_ACCESS(_res_ptr);
19658 LDKCResult_TxOutUtxoLookupErrorZ _res_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(_res_ptr);
19659 FREE(untag_ptr(_res));
19660 CResult_TxOutUtxoLookupErrorZ_free(_res_conv);
19663 static inline uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg) {
19664 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19665 *ret_conv = CResult_TxOutUtxoLookupErrorZ_clone(arg);
19666 return tag_ptr(ret_conv, true);
19668 int64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr"))) TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(uint64_t arg) {
19669 LDKCResult_TxOutUtxoLookupErrorZ* arg_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(arg);
19670 int64_t ret_conv = CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg_conv);
19674 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_clone"))) TS_CResult_TxOutUtxoLookupErrorZ_clone(uint64_t orig) {
19675 LDKCResult_TxOutUtxoLookupErrorZ* orig_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(orig);
19676 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
19677 *ret_conv = CResult_TxOutUtxoLookupErrorZ_clone(orig_conv);
19678 return tag_ptr(ret_conv, true);
19681 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_ok"))) TS_CResult_NoneSendErrorZ_ok() {
19682 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
19683 *ret_conv = CResult_NoneSendErrorZ_ok();
19684 return tag_ptr(ret_conv, true);
19687 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_err"))) TS_CResult_NoneSendErrorZ_err(uint64_t e) {
19688 void* e_ptr = untag_ptr(e);
19689 CHECK_ACCESS(e_ptr);
19690 LDKSendError e_conv = *(LDKSendError*)(e_ptr);
19691 e_conv = SendError_clone((LDKSendError*)untag_ptr(e));
19692 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
19693 *ret_conv = CResult_NoneSendErrorZ_err(e_conv);
19694 return tag_ptr(ret_conv, true);
19697 jboolean __attribute__((export_name("TS_CResult_NoneSendErrorZ_is_ok"))) TS_CResult_NoneSendErrorZ_is_ok(uint64_t o) {
19698 LDKCResult_NoneSendErrorZ* o_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(o);
19699 jboolean ret_conv = CResult_NoneSendErrorZ_is_ok(o_conv);
19703 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_free"))) TS_CResult_NoneSendErrorZ_free(uint64_t _res) {
19704 if (!ptr_is_owned(_res)) return;
19705 void* _res_ptr = untag_ptr(_res);
19706 CHECK_ACCESS(_res_ptr);
19707 LDKCResult_NoneSendErrorZ _res_conv = *(LDKCResult_NoneSendErrorZ*)(_res_ptr);
19708 FREE(untag_ptr(_res));
19709 CResult_NoneSendErrorZ_free(_res_conv);
19712 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_ok"))) TS_CResult_BlindedPathNoneZ_ok(uint64_t o) {
19713 LDKBlindedPath o_conv;
19714 o_conv.inner = untag_ptr(o);
19715 o_conv.is_owned = ptr_is_owned(o);
19716 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19717 o_conv = BlindedPath_clone(&o_conv);
19718 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19719 *ret_conv = CResult_BlindedPathNoneZ_ok(o_conv);
19720 return tag_ptr(ret_conv, true);
19723 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_err"))) TS_CResult_BlindedPathNoneZ_err() {
19724 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19725 *ret_conv = CResult_BlindedPathNoneZ_err();
19726 return tag_ptr(ret_conv, true);
19729 jboolean __attribute__((export_name("TS_CResult_BlindedPathNoneZ_is_ok"))) TS_CResult_BlindedPathNoneZ_is_ok(uint64_t o) {
19730 LDKCResult_BlindedPathNoneZ* o_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(o);
19731 jboolean ret_conv = CResult_BlindedPathNoneZ_is_ok(o_conv);
19735 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_free"))) TS_CResult_BlindedPathNoneZ_free(uint64_t _res) {
19736 if (!ptr_is_owned(_res)) return;
19737 void* _res_ptr = untag_ptr(_res);
19738 CHECK_ACCESS(_res_ptr);
19739 LDKCResult_BlindedPathNoneZ _res_conv = *(LDKCResult_BlindedPathNoneZ*)(_res_ptr);
19740 FREE(untag_ptr(_res));
19741 CResult_BlindedPathNoneZ_free(_res_conv);
19744 static inline uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg) {
19745 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19746 *ret_conv = CResult_BlindedPathNoneZ_clone(arg);
19747 return tag_ptr(ret_conv, true);
19749 int64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone_ptr"))) TS_CResult_BlindedPathNoneZ_clone_ptr(uint64_t arg) {
19750 LDKCResult_BlindedPathNoneZ* arg_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(arg);
19751 int64_t ret_conv = CResult_BlindedPathNoneZ_clone_ptr(arg_conv);
19755 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone"))) TS_CResult_BlindedPathNoneZ_clone(uint64_t orig) {
19756 LDKCResult_BlindedPathNoneZ* orig_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(orig);
19757 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
19758 *ret_conv = CResult_BlindedPathNoneZ_clone(orig_conv);
19759 return tag_ptr(ret_conv, true);
19762 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_ok"))) TS_CResult_BlindedPathDecodeErrorZ_ok(uint64_t o) {
19763 LDKBlindedPath o_conv;
19764 o_conv.inner = untag_ptr(o);
19765 o_conv.is_owned = ptr_is_owned(o);
19766 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19767 o_conv = BlindedPath_clone(&o_conv);
19768 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19769 *ret_conv = CResult_BlindedPathDecodeErrorZ_ok(o_conv);
19770 return tag_ptr(ret_conv, true);
19773 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_err"))) TS_CResult_BlindedPathDecodeErrorZ_err(uint64_t e) {
19774 void* e_ptr = untag_ptr(e);
19775 CHECK_ACCESS(e_ptr);
19776 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19777 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19778 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19779 *ret_conv = CResult_BlindedPathDecodeErrorZ_err(e_conv);
19780 return tag_ptr(ret_conv, true);
19783 jboolean __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_is_ok"))) TS_CResult_BlindedPathDecodeErrorZ_is_ok(uint64_t o) {
19784 LDKCResult_BlindedPathDecodeErrorZ* o_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(o);
19785 jboolean ret_conv = CResult_BlindedPathDecodeErrorZ_is_ok(o_conv);
19789 void __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_free"))) TS_CResult_BlindedPathDecodeErrorZ_free(uint64_t _res) {
19790 if (!ptr_is_owned(_res)) return;
19791 void* _res_ptr = untag_ptr(_res);
19792 CHECK_ACCESS(_res_ptr);
19793 LDKCResult_BlindedPathDecodeErrorZ _res_conv = *(LDKCResult_BlindedPathDecodeErrorZ*)(_res_ptr);
19794 FREE(untag_ptr(_res));
19795 CResult_BlindedPathDecodeErrorZ_free(_res_conv);
19798 static inline uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg) {
19799 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19800 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(arg);
19801 return tag_ptr(ret_conv, true);
19803 int64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(uint64_t arg) {
19804 LDKCResult_BlindedPathDecodeErrorZ* arg_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(arg);
19805 int64_t ret_conv = CResult_BlindedPathDecodeErrorZ_clone_ptr(arg_conv);
19809 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone"))) TS_CResult_BlindedPathDecodeErrorZ_clone(uint64_t orig) {
19810 LDKCResult_BlindedPathDecodeErrorZ* orig_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(orig);
19811 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
19812 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(orig_conv);
19813 return tag_ptr(ret_conv, true);
19816 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_ok"))) TS_CResult_BlindedHopDecodeErrorZ_ok(uint64_t o) {
19817 LDKBlindedHop o_conv;
19818 o_conv.inner = untag_ptr(o);
19819 o_conv.is_owned = ptr_is_owned(o);
19820 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19821 o_conv = BlindedHop_clone(&o_conv);
19822 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19823 *ret_conv = CResult_BlindedHopDecodeErrorZ_ok(o_conv);
19824 return tag_ptr(ret_conv, true);
19827 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_err"))) TS_CResult_BlindedHopDecodeErrorZ_err(uint64_t e) {
19828 void* e_ptr = untag_ptr(e);
19829 CHECK_ACCESS(e_ptr);
19830 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19831 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19832 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19833 *ret_conv = CResult_BlindedHopDecodeErrorZ_err(e_conv);
19834 return tag_ptr(ret_conv, true);
19837 jboolean __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopDecodeErrorZ_is_ok(uint64_t o) {
19838 LDKCResult_BlindedHopDecodeErrorZ* o_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(o);
19839 jboolean ret_conv = CResult_BlindedHopDecodeErrorZ_is_ok(o_conv);
19843 void __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_free"))) TS_CResult_BlindedHopDecodeErrorZ_free(uint64_t _res) {
19844 if (!ptr_is_owned(_res)) return;
19845 void* _res_ptr = untag_ptr(_res);
19846 CHECK_ACCESS(_res_ptr);
19847 LDKCResult_BlindedHopDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopDecodeErrorZ*)(_res_ptr);
19848 FREE(untag_ptr(_res));
19849 CResult_BlindedHopDecodeErrorZ_free(_res_conv);
19852 static inline uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg) {
19853 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19854 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(arg);
19855 return tag_ptr(ret_conv, true);
19857 int64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(uint64_t arg) {
19858 LDKCResult_BlindedHopDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(arg);
19859 int64_t ret_conv = CResult_BlindedHopDecodeErrorZ_clone_ptr(arg_conv);
19863 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone"))) TS_CResult_BlindedHopDecodeErrorZ_clone(uint64_t orig) {
19864 LDKCResult_BlindedHopDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(orig);
19865 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
19866 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(orig_conv);
19867 return tag_ptr(ret_conv, true);
19870 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_ok"))) TS_CResult_u32GraphSyncErrorZ_ok(int32_t o) {
19871 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
19872 *ret_conv = CResult_u32GraphSyncErrorZ_ok(o);
19873 return tag_ptr(ret_conv, true);
19876 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_err"))) TS_CResult_u32GraphSyncErrorZ_err(uint64_t e) {
19877 void* e_ptr = untag_ptr(e);
19878 CHECK_ACCESS(e_ptr);
19879 LDKGraphSyncError e_conv = *(LDKGraphSyncError*)(e_ptr);
19880 e_conv = GraphSyncError_clone((LDKGraphSyncError*)untag_ptr(e));
19881 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
19882 *ret_conv = CResult_u32GraphSyncErrorZ_err(e_conv);
19883 return tag_ptr(ret_conv, true);
19886 jboolean __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_is_ok"))) TS_CResult_u32GraphSyncErrorZ_is_ok(uint64_t o) {
19887 LDKCResult_u32GraphSyncErrorZ* o_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(o);
19888 jboolean ret_conv = CResult_u32GraphSyncErrorZ_is_ok(o_conv);
19892 void __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_free"))) TS_CResult_u32GraphSyncErrorZ_free(uint64_t _res) {
19893 if (!ptr_is_owned(_res)) return;
19894 void* _res_ptr = untag_ptr(_res);
19895 CHECK_ACCESS(_res_ptr);
19896 LDKCResult_u32GraphSyncErrorZ _res_conv = *(LDKCResult_u32GraphSyncErrorZ*)(_res_ptr);
19897 FREE(untag_ptr(_res));
19898 CResult_u32GraphSyncErrorZ_free(_res_conv);
19901 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_ok"))) TS_CResult_NoneErrorZ_ok() {
19902 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19903 *ret_conv = CResult_NoneErrorZ_ok();
19904 return tag_ptr(ret_conv, true);
19907 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_err"))) TS_CResult_NoneErrorZ_err(uint32_t e) {
19908 LDKIOError e_conv = LDKIOError_from_js(e);
19909 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19910 *ret_conv = CResult_NoneErrorZ_err(e_conv);
19911 return tag_ptr(ret_conv, true);
19914 jboolean __attribute__((export_name("TS_CResult_NoneErrorZ_is_ok"))) TS_CResult_NoneErrorZ_is_ok(uint64_t o) {
19915 LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)untag_ptr(o);
19916 jboolean ret_conv = CResult_NoneErrorZ_is_ok(o_conv);
19920 void __attribute__((export_name("TS_CResult_NoneErrorZ_free"))) TS_CResult_NoneErrorZ_free(uint64_t _res) {
19921 if (!ptr_is_owned(_res)) return;
19922 void* _res_ptr = untag_ptr(_res);
19923 CHECK_ACCESS(_res_ptr);
19924 LDKCResult_NoneErrorZ _res_conv = *(LDKCResult_NoneErrorZ*)(_res_ptr);
19925 FREE(untag_ptr(_res));
19926 CResult_NoneErrorZ_free(_res_conv);
19929 static inline uint64_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
19930 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19931 *ret_conv = CResult_NoneErrorZ_clone(arg);
19932 return tag_ptr(ret_conv, true);
19934 int64_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone_ptr"))) TS_CResult_NoneErrorZ_clone_ptr(uint64_t arg) {
19935 LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)untag_ptr(arg);
19936 int64_t ret_conv = CResult_NoneErrorZ_clone_ptr(arg_conv);
19940 uint64_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone"))) TS_CResult_NoneErrorZ_clone(uint64_t orig) {
19941 LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)untag_ptr(orig);
19942 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
19943 *ret_conv = CResult_NoneErrorZ_clone(orig_conv);
19944 return tag_ptr(ret_conv, true);
19947 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_ok"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint64_t o) {
19948 void* o_ptr = untag_ptr(o);
19949 CHECK_ACCESS(o_ptr);
19950 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
19951 o_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(o));
19952 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19953 *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
19954 return tag_ptr(ret_conv, true);
19957 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_err"))) TS_CResult_NetAddressDecodeErrorZ_err(uint64_t e) {
19958 void* e_ptr = untag_ptr(e);
19959 CHECK_ACCESS(e_ptr);
19960 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19961 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19962 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19963 *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
19964 return tag_ptr(ret_conv, true);
19967 jboolean __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_is_ok"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint64_t o) {
19968 LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(o);
19969 jboolean ret_conv = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
19973 void __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_free"))) TS_CResult_NetAddressDecodeErrorZ_free(uint64_t _res) {
19974 if (!ptr_is_owned(_res)) return;
19975 void* _res_ptr = untag_ptr(_res);
19976 CHECK_ACCESS(_res_ptr);
19977 LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(_res_ptr);
19978 FREE(untag_ptr(_res));
19979 CResult_NetAddressDecodeErrorZ_free(_res_conv);
19982 static inline uint64_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
19983 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19984 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
19985 return tag_ptr(ret_conv, true);
19987 int64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone_ptr"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint64_t arg) {
19988 LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(arg);
19989 int64_t ret_conv = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
19993 uint64_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint64_t orig) {
19994 LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)untag_ptr(orig);
19995 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
19996 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
19997 return tag_ptr(ret_conv, true);
20000 void __attribute__((export_name("TS_CVec_UpdateAddHTLCZ_free"))) TS_CVec_UpdateAddHTLCZ_free(uint64_tArray _res) {
20001 LDKCVec_UpdateAddHTLCZ _res_constr;
20002 _res_constr.datalen = _res->arr_len;
20003 if (_res_constr.datalen > 0)
20004 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
20006 _res_constr.data = NULL;
20007 uint64_t* _res_vals = _res->elems;
20008 for (size_t p = 0; p < _res_constr.datalen; p++) {
20009 uint64_t _res_conv_15 = _res_vals[p];
20010 LDKUpdateAddHTLC _res_conv_15_conv;
20011 _res_conv_15_conv.inner = untag_ptr(_res_conv_15);
20012 _res_conv_15_conv.is_owned = ptr_is_owned(_res_conv_15);
20013 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
20014 _res_constr.data[p] = _res_conv_15_conv;
20017 CVec_UpdateAddHTLCZ_free(_res_constr);
20020 void __attribute__((export_name("TS_CVec_UpdateFulfillHTLCZ_free"))) TS_CVec_UpdateFulfillHTLCZ_free(uint64_tArray _res) {
20021 LDKCVec_UpdateFulfillHTLCZ _res_constr;
20022 _res_constr.datalen = _res->arr_len;
20023 if (_res_constr.datalen > 0)
20024 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
20026 _res_constr.data = NULL;
20027 uint64_t* _res_vals = _res->elems;
20028 for (size_t t = 0; t < _res_constr.datalen; t++) {
20029 uint64_t _res_conv_19 = _res_vals[t];
20030 LDKUpdateFulfillHTLC _res_conv_19_conv;
20031 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
20032 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
20033 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
20034 _res_constr.data[t] = _res_conv_19_conv;
20037 CVec_UpdateFulfillHTLCZ_free(_res_constr);
20040 void __attribute__((export_name("TS_CVec_UpdateFailHTLCZ_free"))) TS_CVec_UpdateFailHTLCZ_free(uint64_tArray _res) {
20041 LDKCVec_UpdateFailHTLCZ _res_constr;
20042 _res_constr.datalen = _res->arr_len;
20043 if (_res_constr.datalen > 0)
20044 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
20046 _res_constr.data = NULL;
20047 uint64_t* _res_vals = _res->elems;
20048 for (size_t q = 0; q < _res_constr.datalen; q++) {
20049 uint64_t _res_conv_16 = _res_vals[q];
20050 LDKUpdateFailHTLC _res_conv_16_conv;
20051 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
20052 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
20053 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
20054 _res_constr.data[q] = _res_conv_16_conv;
20057 CVec_UpdateFailHTLCZ_free(_res_constr);
20060 void __attribute__((export_name("TS_CVec_UpdateFailMalformedHTLCZ_free"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint64_tArray _res) {
20061 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
20062 _res_constr.datalen = _res->arr_len;
20063 if (_res_constr.datalen > 0)
20064 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
20066 _res_constr.data = NULL;
20067 uint64_t* _res_vals = _res->elems;
20068 for (size_t z = 0; z < _res_constr.datalen; z++) {
20069 uint64_t _res_conv_25 = _res_vals[z];
20070 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
20071 _res_conv_25_conv.inner = untag_ptr(_res_conv_25);
20072 _res_conv_25_conv.is_owned = ptr_is_owned(_res_conv_25);
20073 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
20074 _res_constr.data[z] = _res_conv_25_conv;
20077 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
20080 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint64_t o) {
20081 LDKAcceptChannel o_conv;
20082 o_conv.inner = untag_ptr(o);
20083 o_conv.is_owned = ptr_is_owned(o);
20084 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20085 o_conv = AcceptChannel_clone(&o_conv);
20086 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20087 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
20088 return tag_ptr(ret_conv, true);
20091 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_err"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint64_t e) {
20092 void* e_ptr = untag_ptr(e);
20093 CHECK_ACCESS(e_ptr);
20094 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20095 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20096 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20097 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
20098 return tag_ptr(ret_conv, true);
20101 jboolean __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_is_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint64_t o) {
20102 LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(o);
20103 jboolean ret_conv = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
20107 void __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_free"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint64_t _res) {
20108 if (!ptr_is_owned(_res)) return;
20109 void* _res_ptr = untag_ptr(_res);
20110 CHECK_ACCESS(_res_ptr);
20111 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(_res_ptr);
20112 FREE(untag_ptr(_res));
20113 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
20116 static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
20117 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20118 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
20119 return tag_ptr(ret_conv, true);
20121 int64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
20122 LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(arg);
20123 int64_t ret_conv = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
20127 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint64_t orig) {
20128 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(orig);
20129 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
20130 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
20131 return tag_ptr(ret_conv, true);
20134 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint64_t o) {
20135 LDKAnnouncementSignatures o_conv;
20136 o_conv.inner = untag_ptr(o);
20137 o_conv.is_owned = ptr_is_owned(o);
20138 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20139 o_conv = AnnouncementSignatures_clone(&o_conv);
20140 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20141 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
20142 return tag_ptr(ret_conv, true);
20145 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint64_t e) {
20146 void* e_ptr = untag_ptr(e);
20147 CHECK_ACCESS(e_ptr);
20148 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20149 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20150 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20151 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
20152 return tag_ptr(ret_conv, true);
20155 jboolean __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint64_t o) {
20156 LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(o);
20157 jboolean ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
20161 void __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_free"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint64_t _res) {
20162 if (!ptr_is_owned(_res)) return;
20163 void* _res_ptr = untag_ptr(_res);
20164 CHECK_ACCESS(_res_ptr);
20165 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(_res_ptr);
20166 FREE(untag_ptr(_res));
20167 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
20170 static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
20171 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20172 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
20173 return tag_ptr(ret_conv, true);
20175 int64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
20176 LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(arg);
20177 int64_t ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
20181 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint64_t orig) {
20182 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(orig);
20183 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
20184 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
20185 return tag_ptr(ret_conv, true);
20188 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint64_t o) {
20189 LDKChannelReestablish o_conv;
20190 o_conv.inner = untag_ptr(o);
20191 o_conv.is_owned = ptr_is_owned(o);
20192 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20193 o_conv = ChannelReestablish_clone(&o_conv);
20194 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20195 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
20196 return tag_ptr(ret_conv, true);
20199 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint64_t e) {
20200 void* e_ptr = untag_ptr(e);
20201 CHECK_ACCESS(e_ptr);
20202 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20203 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20204 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20205 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
20206 return tag_ptr(ret_conv, true);
20209 jboolean __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_is_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint64_t o) {
20210 LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(o);
20211 jboolean ret_conv = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
20215 void __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_free"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint64_t _res) {
20216 if (!ptr_is_owned(_res)) return;
20217 void* _res_ptr = untag_ptr(_res);
20218 CHECK_ACCESS(_res_ptr);
20219 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(_res_ptr);
20220 FREE(untag_ptr(_res));
20221 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
20224 static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
20225 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20226 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
20227 return tag_ptr(ret_conv, true);
20229 int64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint64_t arg) {
20230 LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(arg);
20231 int64_t ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
20235 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint64_t orig) {
20236 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(orig);
20237 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
20238 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
20239 return tag_ptr(ret_conv, true);
20242 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint64_t o) {
20243 LDKClosingSigned o_conv;
20244 o_conv.inner = untag_ptr(o);
20245 o_conv.is_owned = ptr_is_owned(o);
20246 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20247 o_conv = ClosingSigned_clone(&o_conv);
20248 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20249 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
20250 return tag_ptr(ret_conv, true);
20253 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_err"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint64_t e) {
20254 void* e_ptr = untag_ptr(e);
20255 CHECK_ACCESS(e_ptr);
20256 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20257 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20258 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20259 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
20260 return tag_ptr(ret_conv, true);
20263 jboolean __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint64_t o) {
20264 LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(o);
20265 jboolean ret_conv = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
20269 void __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_free"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint64_t _res) {
20270 if (!ptr_is_owned(_res)) return;
20271 void* _res_ptr = untag_ptr(_res);
20272 CHECK_ACCESS(_res_ptr);
20273 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(_res_ptr);
20274 FREE(untag_ptr(_res));
20275 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
20278 static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
20279 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20280 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
20281 return tag_ptr(ret_conv, true);
20283 int64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
20284 LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(arg);
20285 int64_t ret_conv = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
20289 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint64_t orig) {
20290 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(orig);
20291 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
20292 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
20293 return tag_ptr(ret_conv, true);
20296 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(uint64_t o) {
20297 LDKClosingSignedFeeRange o_conv;
20298 o_conv.inner = untag_ptr(o);
20299 o_conv.is_owned = ptr_is_owned(o);
20300 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20301 o_conv = ClosingSignedFeeRange_clone(&o_conv);
20302 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20303 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
20304 return tag_ptr(ret_conv, true);
20307 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(uint64_t e) {
20308 void* e_ptr = untag_ptr(e);
20309 CHECK_ACCESS(e_ptr);
20310 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20311 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20312 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20313 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
20314 return tag_ptr(ret_conv, true);
20317 jboolean __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint64_t o) {
20318 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(o);
20319 jboolean ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
20323 void __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint64_t _res) {
20324 if (!ptr_is_owned(_res)) return;
20325 void* _res_ptr = untag_ptr(_res);
20326 CHECK_ACCESS(_res_ptr);
20327 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(_res_ptr);
20328 FREE(untag_ptr(_res));
20329 CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
20332 static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
20333 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20334 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
20335 return tag_ptr(ret_conv, true);
20337 int64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
20338 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(arg);
20339 int64_t ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
20343 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint64_t orig) {
20344 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(orig);
20345 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
20346 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig_conv);
20347 return tag_ptr(ret_conv, true);
20350 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint64_t o) {
20351 LDKCommitmentSigned o_conv;
20352 o_conv.inner = untag_ptr(o);
20353 o_conv.is_owned = ptr_is_owned(o);
20354 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20355 o_conv = CommitmentSigned_clone(&o_conv);
20356 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20357 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
20358 return tag_ptr(ret_conv, true);
20361 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint64_t e) {
20362 void* e_ptr = untag_ptr(e);
20363 CHECK_ACCESS(e_ptr);
20364 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20365 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20366 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20367 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
20368 return tag_ptr(ret_conv, true);
20371 jboolean __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_is_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint64_t o) {
20372 LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(o);
20373 jboolean ret_conv = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
20377 void __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_free"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint64_t _res) {
20378 if (!ptr_is_owned(_res)) return;
20379 void* _res_ptr = untag_ptr(_res);
20380 CHECK_ACCESS(_res_ptr);
20381 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(_res_ptr);
20382 FREE(untag_ptr(_res));
20383 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
20386 static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
20387 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20388 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
20389 return tag_ptr(ret_conv, true);
20391 int64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
20392 LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(arg);
20393 int64_t ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
20397 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint64_t orig) {
20398 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(orig);
20399 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
20400 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
20401 return tag_ptr(ret_conv, true);
20404 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint64_t o) {
20405 LDKFundingCreated o_conv;
20406 o_conv.inner = untag_ptr(o);
20407 o_conv.is_owned = ptr_is_owned(o);
20408 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20409 o_conv = FundingCreated_clone(&o_conv);
20410 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20411 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
20412 return tag_ptr(ret_conv, true);
20415 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_err"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint64_t e) {
20416 void* e_ptr = untag_ptr(e);
20417 CHECK_ACCESS(e_ptr);
20418 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20419 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20420 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20421 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
20422 return tag_ptr(ret_conv, true);
20425 jboolean __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_is_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint64_t o) {
20426 LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(o);
20427 jboolean ret_conv = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
20431 void __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_free"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint64_t _res) {
20432 if (!ptr_is_owned(_res)) return;
20433 void* _res_ptr = untag_ptr(_res);
20434 CHECK_ACCESS(_res_ptr);
20435 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(_res_ptr);
20436 FREE(untag_ptr(_res));
20437 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
20440 static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
20441 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20442 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
20443 return tag_ptr(ret_conv, true);
20445 int64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint64_t arg) {
20446 LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(arg);
20447 int64_t ret_conv = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
20451 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint64_t orig) {
20452 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(orig);
20453 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
20454 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
20455 return tag_ptr(ret_conv, true);
20458 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_ok"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint64_t o) {
20459 LDKFundingSigned o_conv;
20460 o_conv.inner = untag_ptr(o);
20461 o_conv.is_owned = ptr_is_owned(o);
20462 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20463 o_conv = FundingSigned_clone(&o_conv);
20464 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20465 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
20466 return tag_ptr(ret_conv, true);
20469 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_err"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint64_t e) {
20470 void* e_ptr = untag_ptr(e);
20471 CHECK_ACCESS(e_ptr);
20472 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20473 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20474 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20475 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
20476 return tag_ptr(ret_conv, true);
20479 jboolean __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_is_ok"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint64_t o) {
20480 LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(o);
20481 jboolean ret_conv = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
20485 void __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_free"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint64_t _res) {
20486 if (!ptr_is_owned(_res)) return;
20487 void* _res_ptr = untag_ptr(_res);
20488 CHECK_ACCESS(_res_ptr);
20489 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(_res_ptr);
20490 FREE(untag_ptr(_res));
20491 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
20494 static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
20495 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20496 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
20497 return tag_ptr(ret_conv, true);
20499 int64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
20500 LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(arg);
20501 int64_t ret_conv = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
20505 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint64_t orig) {
20506 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(orig);
20507 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
20508 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
20509 return tag_ptr(ret_conv, true);
20512 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_ok(uint64_t o) {
20513 LDKChannelReady o_conv;
20514 o_conv.inner = untag_ptr(o);
20515 o_conv.is_owned = ptr_is_owned(o);
20516 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20517 o_conv = ChannelReady_clone(&o_conv);
20518 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20519 *ret_conv = CResult_ChannelReadyDecodeErrorZ_ok(o_conv);
20520 return tag_ptr(ret_conv, true);
20523 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_err"))) TS_CResult_ChannelReadyDecodeErrorZ_err(uint64_t e) {
20524 void* e_ptr = untag_ptr(e);
20525 CHECK_ACCESS(e_ptr);
20526 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20527 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20528 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20529 *ret_conv = CResult_ChannelReadyDecodeErrorZ_err(e_conv);
20530 return tag_ptr(ret_conv, true);
20533 jboolean __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_is_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_is_ok(uint64_t o) {
20534 LDKCResult_ChannelReadyDecodeErrorZ* o_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(o);
20535 jboolean ret_conv = CResult_ChannelReadyDecodeErrorZ_is_ok(o_conv);
20539 void __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_free"))) TS_CResult_ChannelReadyDecodeErrorZ_free(uint64_t _res) {
20540 if (!ptr_is_owned(_res)) return;
20541 void* _res_ptr = untag_ptr(_res);
20542 CHECK_ACCESS(_res_ptr);
20543 LDKCResult_ChannelReadyDecodeErrorZ _res_conv = *(LDKCResult_ChannelReadyDecodeErrorZ*)(_res_ptr);
20544 FREE(untag_ptr(_res));
20545 CResult_ChannelReadyDecodeErrorZ_free(_res_conv);
20548 static inline uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg) {
20549 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20550 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(arg);
20551 return tag_ptr(ret_conv, true);
20553 int64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(uint64_t arg) {
20554 LDKCResult_ChannelReadyDecodeErrorZ* arg_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(arg);
20555 int64_t ret_conv = CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg_conv);
20559 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone"))) TS_CResult_ChannelReadyDecodeErrorZ_clone(uint64_t orig) {
20560 LDKCResult_ChannelReadyDecodeErrorZ* orig_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(orig);
20561 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
20562 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(orig_conv);
20563 return tag_ptr(ret_conv, true);
20566 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_ok"))) TS_CResult_InitDecodeErrorZ_ok(uint64_t o) {
20568 o_conv.inner = untag_ptr(o);
20569 o_conv.is_owned = ptr_is_owned(o);
20570 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20571 o_conv = Init_clone(&o_conv);
20572 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20573 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
20574 return tag_ptr(ret_conv, true);
20577 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_err"))) TS_CResult_InitDecodeErrorZ_err(uint64_t e) {
20578 void* e_ptr = untag_ptr(e);
20579 CHECK_ACCESS(e_ptr);
20580 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20581 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20582 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20583 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
20584 return tag_ptr(ret_conv, true);
20587 jboolean __attribute__((export_name("TS_CResult_InitDecodeErrorZ_is_ok"))) TS_CResult_InitDecodeErrorZ_is_ok(uint64_t o) {
20588 LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(o);
20589 jboolean ret_conv = CResult_InitDecodeErrorZ_is_ok(o_conv);
20593 void __attribute__((export_name("TS_CResult_InitDecodeErrorZ_free"))) TS_CResult_InitDecodeErrorZ_free(uint64_t _res) {
20594 if (!ptr_is_owned(_res)) return;
20595 void* _res_ptr = untag_ptr(_res);
20596 CHECK_ACCESS(_res_ptr);
20597 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(_res_ptr);
20598 FREE(untag_ptr(_res));
20599 CResult_InitDecodeErrorZ_free(_res_conv);
20602 static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
20603 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20604 *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
20605 return tag_ptr(ret_conv, true);
20607 int64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone_ptr"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint64_t arg) {
20608 LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(arg);
20609 int64_t ret_conv = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
20613 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone"))) TS_CResult_InitDecodeErrorZ_clone(uint64_t orig) {
20614 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(orig);
20615 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
20616 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
20617 return tag_ptr(ret_conv, true);
20620 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_ok"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint64_t o) {
20621 LDKOpenChannel o_conv;
20622 o_conv.inner = untag_ptr(o);
20623 o_conv.is_owned = ptr_is_owned(o);
20624 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20625 o_conv = OpenChannel_clone(&o_conv);
20626 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20627 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
20628 return tag_ptr(ret_conv, true);
20631 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_err"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint64_t e) {
20632 void* e_ptr = untag_ptr(e);
20633 CHECK_ACCESS(e_ptr);
20634 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20635 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20636 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20637 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
20638 return tag_ptr(ret_conv, true);
20641 jboolean __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_is_ok"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint64_t o) {
20642 LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(o);
20643 jboolean ret_conv = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
20647 void __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_free"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint64_t _res) {
20648 if (!ptr_is_owned(_res)) return;
20649 void* _res_ptr = untag_ptr(_res);
20650 CHECK_ACCESS(_res_ptr);
20651 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(_res_ptr);
20652 FREE(untag_ptr(_res));
20653 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
20656 static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
20657 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20658 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
20659 return tag_ptr(ret_conv, true);
20661 int64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone_ptr"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
20662 LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(arg);
20663 int64_t ret_conv = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
20667 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint64_t orig) {
20668 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(orig);
20669 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
20670 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
20671 return tag_ptr(ret_conv, true);
20674 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint64_t o) {
20675 LDKRevokeAndACK o_conv;
20676 o_conv.inner = untag_ptr(o);
20677 o_conv.is_owned = ptr_is_owned(o);
20678 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20679 o_conv = RevokeAndACK_clone(&o_conv);
20680 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20681 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
20682 return tag_ptr(ret_conv, true);
20685 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint64_t e) {
20686 void* e_ptr = untag_ptr(e);
20687 CHECK_ACCESS(e_ptr);
20688 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20689 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20690 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20691 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
20692 return tag_ptr(ret_conv, true);
20695 jboolean __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_is_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint64_t o) {
20696 LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(o);
20697 jboolean ret_conv = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
20701 void __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_free"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint64_t _res) {
20702 if (!ptr_is_owned(_res)) return;
20703 void* _res_ptr = untag_ptr(_res);
20704 CHECK_ACCESS(_res_ptr);
20705 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(_res_ptr);
20706 FREE(untag_ptr(_res));
20707 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
20710 static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
20711 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20712 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
20713 return tag_ptr(ret_conv, true);
20715 int64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint64_t arg) {
20716 LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(arg);
20717 int64_t ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
20721 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint64_t orig) {
20722 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(orig);
20723 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
20724 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
20725 return tag_ptr(ret_conv, true);
20728 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_ok"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint64_t o) {
20729 LDKShutdown o_conv;
20730 o_conv.inner = untag_ptr(o);
20731 o_conv.is_owned = ptr_is_owned(o);
20732 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20733 o_conv = Shutdown_clone(&o_conv);
20734 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20735 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
20736 return tag_ptr(ret_conv, true);
20739 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_err"))) TS_CResult_ShutdownDecodeErrorZ_err(uint64_t e) {
20740 void* e_ptr = untag_ptr(e);
20741 CHECK_ACCESS(e_ptr);
20742 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20743 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20744 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20745 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
20746 return tag_ptr(ret_conv, true);
20749 jboolean __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_is_ok"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint64_t o) {
20750 LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(o);
20751 jboolean ret_conv = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
20755 void __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_free"))) TS_CResult_ShutdownDecodeErrorZ_free(uint64_t _res) {
20756 if (!ptr_is_owned(_res)) return;
20757 void* _res_ptr = untag_ptr(_res);
20758 CHECK_ACCESS(_res_ptr);
20759 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(_res_ptr);
20760 FREE(untag_ptr(_res));
20761 CResult_ShutdownDecodeErrorZ_free(_res_conv);
20764 static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
20765 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20766 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
20767 return tag_ptr(ret_conv, true);
20769 int64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint64_t arg) {
20770 LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(arg);
20771 int64_t ret_conv = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
20775 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint64_t orig) {
20776 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(orig);
20777 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
20778 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
20779 return tag_ptr(ret_conv, true);
20782 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint64_t o) {
20783 LDKUpdateFailHTLC o_conv;
20784 o_conv.inner = untag_ptr(o);
20785 o_conv.is_owned = ptr_is_owned(o);
20786 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20787 o_conv = UpdateFailHTLC_clone(&o_conv);
20788 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20789 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
20790 return tag_ptr(ret_conv, true);
20793 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint64_t e) {
20794 void* e_ptr = untag_ptr(e);
20795 CHECK_ACCESS(e_ptr);
20796 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20797 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20798 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20799 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
20800 return tag_ptr(ret_conv, true);
20803 jboolean __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint64_t o) {
20804 LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(o);
20805 jboolean ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
20809 void __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint64_t _res) {
20810 if (!ptr_is_owned(_res)) return;
20811 void* _res_ptr = untag_ptr(_res);
20812 CHECK_ACCESS(_res_ptr);
20813 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(_res_ptr);
20814 FREE(untag_ptr(_res));
20815 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
20818 static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
20819 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20820 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
20821 return tag_ptr(ret_conv, true);
20823 int64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20824 LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(arg);
20825 int64_t ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
20829 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint64_t orig) {
20830 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(orig);
20831 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
20832 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
20833 return tag_ptr(ret_conv, true);
20836 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint64_t o) {
20837 LDKUpdateFailMalformedHTLC o_conv;
20838 o_conv.inner = untag_ptr(o);
20839 o_conv.is_owned = ptr_is_owned(o);
20840 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20841 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
20842 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20843 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
20844 return tag_ptr(ret_conv, true);
20847 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint64_t e) {
20848 void* e_ptr = untag_ptr(e);
20849 CHECK_ACCESS(e_ptr);
20850 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20851 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20852 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20853 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
20854 return tag_ptr(ret_conv, true);
20857 jboolean __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint64_t o) {
20858 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(o);
20859 jboolean ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
20863 void __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint64_t _res) {
20864 if (!ptr_is_owned(_res)) return;
20865 void* _res_ptr = untag_ptr(_res);
20866 CHECK_ACCESS(_res_ptr);
20867 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(_res_ptr);
20868 FREE(untag_ptr(_res));
20869 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
20872 static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
20873 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20874 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
20875 return tag_ptr(ret_conv, true);
20877 int64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20878 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(arg);
20879 int64_t ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
20883 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint64_t orig) {
20884 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(orig);
20885 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
20886 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
20887 return tag_ptr(ret_conv, true);
20890 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint64_t o) {
20891 LDKUpdateFee o_conv;
20892 o_conv.inner = untag_ptr(o);
20893 o_conv.is_owned = ptr_is_owned(o);
20894 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20895 o_conv = UpdateFee_clone(&o_conv);
20896 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20897 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
20898 return tag_ptr(ret_conv, true);
20901 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_err"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint64_t e) {
20902 void* e_ptr = untag_ptr(e);
20903 CHECK_ACCESS(e_ptr);
20904 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20905 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20906 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20907 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
20908 return tag_ptr(ret_conv, true);
20911 jboolean __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_is_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint64_t o) {
20912 LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(o);
20913 jboolean ret_conv = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
20917 void __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_free"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint64_t _res) {
20918 if (!ptr_is_owned(_res)) return;
20919 void* _res_ptr = untag_ptr(_res);
20920 CHECK_ACCESS(_res_ptr);
20921 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(_res_ptr);
20922 FREE(untag_ptr(_res));
20923 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
20926 static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
20927 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20928 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
20929 return tag_ptr(ret_conv, true);
20931 int64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint64_t arg) {
20932 LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(arg);
20933 int64_t ret_conv = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
20937 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint64_t orig) {
20938 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(orig);
20939 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
20940 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
20941 return tag_ptr(ret_conv, true);
20944 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint64_t o) {
20945 LDKUpdateFulfillHTLC o_conv;
20946 o_conv.inner = untag_ptr(o);
20947 o_conv.is_owned = ptr_is_owned(o);
20948 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20949 o_conv = UpdateFulfillHTLC_clone(&o_conv);
20950 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20951 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
20952 return tag_ptr(ret_conv, true);
20955 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint64_t e) {
20956 void* e_ptr = untag_ptr(e);
20957 CHECK_ACCESS(e_ptr);
20958 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20959 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20960 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20961 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
20962 return tag_ptr(ret_conv, true);
20965 jboolean __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint64_t o) {
20966 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(o);
20967 jboolean ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
20971 void __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint64_t _res) {
20972 if (!ptr_is_owned(_res)) return;
20973 void* _res_ptr = untag_ptr(_res);
20974 CHECK_ACCESS(_res_ptr);
20975 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(_res_ptr);
20976 FREE(untag_ptr(_res));
20977 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
20980 static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
20981 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20982 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
20983 return tag_ptr(ret_conv, true);
20985 int64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
20986 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(arg);
20987 int64_t ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
20991 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint64_t orig) {
20992 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(orig);
20993 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
20994 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
20995 return tag_ptr(ret_conv, true);
20998 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint64_t o) {
20999 LDKUpdateAddHTLC o_conv;
21000 o_conv.inner = untag_ptr(o);
21001 o_conv.is_owned = ptr_is_owned(o);
21002 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21003 o_conv = UpdateAddHTLC_clone(&o_conv);
21004 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21005 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
21006 return tag_ptr(ret_conv, true);
21009 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint64_t e) {
21010 void* e_ptr = untag_ptr(e);
21011 CHECK_ACCESS(e_ptr);
21012 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21013 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21014 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21015 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
21016 return tag_ptr(ret_conv, true);
21019 jboolean __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint64_t o) {
21020 LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(o);
21021 jboolean ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
21025 void __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_free"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint64_t _res) {
21026 if (!ptr_is_owned(_res)) return;
21027 void* _res_ptr = untag_ptr(_res);
21028 CHECK_ACCESS(_res_ptr);
21029 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(_res_ptr);
21030 FREE(untag_ptr(_res));
21031 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
21034 static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
21035 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21036 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
21037 return tag_ptr(ret_conv, true);
21039 int64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
21040 LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(arg);
21041 int64_t ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
21045 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint64_t orig) {
21046 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(orig);
21047 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
21048 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
21049 return tag_ptr(ret_conv, true);
21052 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_ok"))) TS_CResult_OnionMessageDecodeErrorZ_ok(uint64_t o) {
21053 LDKOnionMessage o_conv;
21054 o_conv.inner = untag_ptr(o);
21055 o_conv.is_owned = ptr_is_owned(o);
21056 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21057 o_conv = OnionMessage_clone(&o_conv);
21058 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21059 *ret_conv = CResult_OnionMessageDecodeErrorZ_ok(o_conv);
21060 return tag_ptr(ret_conv, true);
21063 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_err"))) TS_CResult_OnionMessageDecodeErrorZ_err(uint64_t e) {
21064 void* e_ptr = untag_ptr(e);
21065 CHECK_ACCESS(e_ptr);
21066 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21067 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21068 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21069 *ret_conv = CResult_OnionMessageDecodeErrorZ_err(e_conv);
21070 return tag_ptr(ret_conv, true);
21073 jboolean __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_is_ok"))) TS_CResult_OnionMessageDecodeErrorZ_is_ok(uint64_t o) {
21074 LDKCResult_OnionMessageDecodeErrorZ* o_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(o);
21075 jboolean ret_conv = CResult_OnionMessageDecodeErrorZ_is_ok(o_conv);
21079 void __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_free"))) TS_CResult_OnionMessageDecodeErrorZ_free(uint64_t _res) {
21080 if (!ptr_is_owned(_res)) return;
21081 void* _res_ptr = untag_ptr(_res);
21082 CHECK_ACCESS(_res_ptr);
21083 LDKCResult_OnionMessageDecodeErrorZ _res_conv = *(LDKCResult_OnionMessageDecodeErrorZ*)(_res_ptr);
21084 FREE(untag_ptr(_res));
21085 CResult_OnionMessageDecodeErrorZ_free(_res_conv);
21088 static inline uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg) {
21089 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21090 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(arg);
21091 return tag_ptr(ret_conv, true);
21093 int64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone_ptr"))) TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
21094 LDKCResult_OnionMessageDecodeErrorZ* arg_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(arg);
21095 int64_t ret_conv = CResult_OnionMessageDecodeErrorZ_clone_ptr(arg_conv);
21099 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone"))) TS_CResult_OnionMessageDecodeErrorZ_clone(uint64_t orig) {
21100 LDKCResult_OnionMessageDecodeErrorZ* orig_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(orig);
21101 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
21102 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(orig_conv);
21103 return tag_ptr(ret_conv, true);
21106 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_ok"))) TS_CResult_PingDecodeErrorZ_ok(uint64_t o) {
21108 o_conv.inner = untag_ptr(o);
21109 o_conv.is_owned = ptr_is_owned(o);
21110 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21111 o_conv = Ping_clone(&o_conv);
21112 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21113 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
21114 return tag_ptr(ret_conv, true);
21117 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_err"))) TS_CResult_PingDecodeErrorZ_err(uint64_t e) {
21118 void* e_ptr = untag_ptr(e);
21119 CHECK_ACCESS(e_ptr);
21120 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21121 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21122 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21123 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
21124 return tag_ptr(ret_conv, true);
21127 jboolean __attribute__((export_name("TS_CResult_PingDecodeErrorZ_is_ok"))) TS_CResult_PingDecodeErrorZ_is_ok(uint64_t o) {
21128 LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(o);
21129 jboolean ret_conv = CResult_PingDecodeErrorZ_is_ok(o_conv);
21133 void __attribute__((export_name("TS_CResult_PingDecodeErrorZ_free"))) TS_CResult_PingDecodeErrorZ_free(uint64_t _res) {
21134 if (!ptr_is_owned(_res)) return;
21135 void* _res_ptr = untag_ptr(_res);
21136 CHECK_ACCESS(_res_ptr);
21137 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(_res_ptr);
21138 FREE(untag_ptr(_res));
21139 CResult_PingDecodeErrorZ_free(_res_conv);
21142 static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
21143 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21144 *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
21145 return tag_ptr(ret_conv, true);
21147 int64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone_ptr"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint64_t arg) {
21148 LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(arg);
21149 int64_t ret_conv = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
21153 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone"))) TS_CResult_PingDecodeErrorZ_clone(uint64_t orig) {
21154 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(orig);
21155 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
21156 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
21157 return tag_ptr(ret_conv, true);
21160 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_ok"))) TS_CResult_PongDecodeErrorZ_ok(uint64_t o) {
21162 o_conv.inner = untag_ptr(o);
21163 o_conv.is_owned = ptr_is_owned(o);
21164 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21165 o_conv = Pong_clone(&o_conv);
21166 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21167 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
21168 return tag_ptr(ret_conv, true);
21171 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_err"))) TS_CResult_PongDecodeErrorZ_err(uint64_t e) {
21172 void* e_ptr = untag_ptr(e);
21173 CHECK_ACCESS(e_ptr);
21174 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21175 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21176 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21177 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
21178 return tag_ptr(ret_conv, true);
21181 jboolean __attribute__((export_name("TS_CResult_PongDecodeErrorZ_is_ok"))) TS_CResult_PongDecodeErrorZ_is_ok(uint64_t o) {
21182 LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(o);
21183 jboolean ret_conv = CResult_PongDecodeErrorZ_is_ok(o_conv);
21187 void __attribute__((export_name("TS_CResult_PongDecodeErrorZ_free"))) TS_CResult_PongDecodeErrorZ_free(uint64_t _res) {
21188 if (!ptr_is_owned(_res)) return;
21189 void* _res_ptr = untag_ptr(_res);
21190 CHECK_ACCESS(_res_ptr);
21191 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(_res_ptr);
21192 FREE(untag_ptr(_res));
21193 CResult_PongDecodeErrorZ_free(_res_conv);
21196 static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
21197 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21198 *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
21199 return tag_ptr(ret_conv, true);
21201 int64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone_ptr"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint64_t arg) {
21202 LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(arg);
21203 int64_t ret_conv = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
21207 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone"))) TS_CResult_PongDecodeErrorZ_clone(uint64_t orig) {
21208 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(orig);
21209 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
21210 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
21211 return tag_ptr(ret_conv, true);
21214 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
21215 LDKUnsignedChannelAnnouncement o_conv;
21216 o_conv.inner = untag_ptr(o);
21217 o_conv.is_owned = ptr_is_owned(o);
21218 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21219 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
21220 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21221 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
21222 return tag_ptr(ret_conv, true);
21225 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
21226 void* e_ptr = untag_ptr(e);
21227 CHECK_ACCESS(e_ptr);
21228 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21229 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21230 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21231 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
21232 return tag_ptr(ret_conv, true);
21235 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21236 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
21237 jboolean ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
21241 void __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
21242 if (!ptr_is_owned(_res)) return;
21243 void* _res_ptr = untag_ptr(_res);
21244 CHECK_ACCESS(_res_ptr);
21245 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(_res_ptr);
21246 FREE(untag_ptr(_res));
21247 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
21250 static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21251 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21252 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
21253 return tag_ptr(ret_conv, true);
21255 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21256 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
21257 int64_t ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21261 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21262 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
21263 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
21264 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
21265 return tag_ptr(ret_conv, true);
21268 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
21269 LDKChannelAnnouncement o_conv;
21270 o_conv.inner = untag_ptr(o);
21271 o_conv.is_owned = ptr_is_owned(o);
21272 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21273 o_conv = ChannelAnnouncement_clone(&o_conv);
21274 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21275 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
21276 return tag_ptr(ret_conv, true);
21279 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
21280 void* e_ptr = untag_ptr(e);
21281 CHECK_ACCESS(e_ptr);
21282 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21283 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21284 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21285 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
21286 return tag_ptr(ret_conv, true);
21289 jboolean __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21290 LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
21291 jboolean ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
21295 void __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
21296 if (!ptr_is_owned(_res)) return;
21297 void* _res_ptr = untag_ptr(_res);
21298 CHECK_ACCESS(_res_ptr);
21299 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(_res_ptr);
21300 FREE(untag_ptr(_res));
21301 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
21304 static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21305 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21306 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
21307 return tag_ptr(ret_conv, true);
21309 int64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21310 LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
21311 int64_t ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21315 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21316 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
21317 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
21318 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
21319 return tag_ptr(ret_conv, true);
21322 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint64_t o) {
21323 LDKUnsignedChannelUpdate o_conv;
21324 o_conv.inner = untag_ptr(o);
21325 o_conv.is_owned = ptr_is_owned(o);
21326 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21327 o_conv = UnsignedChannelUpdate_clone(&o_conv);
21328 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21329 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
21330 return tag_ptr(ret_conv, true);
21333 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint64_t e) {
21334 void* e_ptr = untag_ptr(e);
21335 CHECK_ACCESS(e_ptr);
21336 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21337 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21338 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21339 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
21340 return tag_ptr(ret_conv, true);
21343 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
21344 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(o);
21345 jboolean ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
21349 void __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint64_t _res) {
21350 if (!ptr_is_owned(_res)) return;
21351 void* _res_ptr = untag_ptr(_res);
21352 CHECK_ACCESS(_res_ptr);
21353 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(_res_ptr);
21354 FREE(untag_ptr(_res));
21355 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
21358 static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
21359 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21360 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
21361 return tag_ptr(ret_conv, true);
21363 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
21364 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(arg);
21365 int64_t ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
21369 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
21370 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(orig);
21371 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
21372 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
21373 return tag_ptr(ret_conv, true);
21376 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint64_t o) {
21377 LDKChannelUpdate o_conv;
21378 o_conv.inner = untag_ptr(o);
21379 o_conv.is_owned = ptr_is_owned(o);
21380 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21381 o_conv = ChannelUpdate_clone(&o_conv);
21382 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21383 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
21384 return tag_ptr(ret_conv, true);
21387 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint64_t e) {
21388 void* e_ptr = untag_ptr(e);
21389 CHECK_ACCESS(e_ptr);
21390 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21391 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21392 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21393 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
21394 return tag_ptr(ret_conv, true);
21397 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
21398 LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(o);
21399 jboolean ret_conv = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
21403 void __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_free"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint64_t _res) {
21404 if (!ptr_is_owned(_res)) return;
21405 void* _res_ptr = untag_ptr(_res);
21406 CHECK_ACCESS(_res_ptr);
21407 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(_res_ptr);
21408 FREE(untag_ptr(_res));
21409 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
21412 static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
21413 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21414 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
21415 return tag_ptr(ret_conv, true);
21417 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
21418 LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(arg);
21419 int64_t ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
21423 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
21424 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(orig);
21425 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
21426 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
21427 return tag_ptr(ret_conv, true);
21430 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint64_t o) {
21431 LDKErrorMessage o_conv;
21432 o_conv.inner = untag_ptr(o);
21433 o_conv.is_owned = ptr_is_owned(o);
21434 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21435 o_conv = ErrorMessage_clone(&o_conv);
21436 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21437 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
21438 return tag_ptr(ret_conv, true);
21441 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_err"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint64_t e) {
21442 void* e_ptr = untag_ptr(e);
21443 CHECK_ACCESS(e_ptr);
21444 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21445 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21446 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21447 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
21448 return tag_ptr(ret_conv, true);
21451 jboolean __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_is_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint64_t o) {
21452 LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(o);
21453 jboolean ret_conv = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
21457 void __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_free"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint64_t _res) {
21458 if (!ptr_is_owned(_res)) return;
21459 void* _res_ptr = untag_ptr(_res);
21460 CHECK_ACCESS(_res_ptr);
21461 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(_res_ptr);
21462 FREE(untag_ptr(_res));
21463 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
21466 static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
21467 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21468 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
21469 return tag_ptr(ret_conv, true);
21471 int64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
21472 LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(arg);
21473 int64_t ret_conv = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
21477 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint64_t orig) {
21478 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(orig);
21479 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
21480 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
21481 return tag_ptr(ret_conv, true);
21484 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_ok"))) TS_CResult_WarningMessageDecodeErrorZ_ok(uint64_t o) {
21485 LDKWarningMessage o_conv;
21486 o_conv.inner = untag_ptr(o);
21487 o_conv.is_owned = ptr_is_owned(o);
21488 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21489 o_conv = WarningMessage_clone(&o_conv);
21490 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21491 *ret_conv = CResult_WarningMessageDecodeErrorZ_ok(o_conv);
21492 return tag_ptr(ret_conv, true);
21495 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_err"))) TS_CResult_WarningMessageDecodeErrorZ_err(uint64_t e) {
21496 void* e_ptr = untag_ptr(e);
21497 CHECK_ACCESS(e_ptr);
21498 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21499 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21500 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21501 *ret_conv = CResult_WarningMessageDecodeErrorZ_err(e_conv);
21502 return tag_ptr(ret_conv, true);
21505 jboolean __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_is_ok"))) TS_CResult_WarningMessageDecodeErrorZ_is_ok(uint64_t o) {
21506 LDKCResult_WarningMessageDecodeErrorZ* o_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(o);
21507 jboolean ret_conv = CResult_WarningMessageDecodeErrorZ_is_ok(o_conv);
21511 void __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_free"))) TS_CResult_WarningMessageDecodeErrorZ_free(uint64_t _res) {
21512 if (!ptr_is_owned(_res)) return;
21513 void* _res_ptr = untag_ptr(_res);
21514 CHECK_ACCESS(_res_ptr);
21515 LDKCResult_WarningMessageDecodeErrorZ _res_conv = *(LDKCResult_WarningMessageDecodeErrorZ*)(_res_ptr);
21516 FREE(untag_ptr(_res));
21517 CResult_WarningMessageDecodeErrorZ_free(_res_conv);
21520 static inline uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg) {
21521 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21522 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(arg);
21523 return tag_ptr(ret_conv, true);
21525 int64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone_ptr"))) TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
21526 LDKCResult_WarningMessageDecodeErrorZ* arg_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(arg);
21527 int64_t ret_conv = CResult_WarningMessageDecodeErrorZ_clone_ptr(arg_conv);
21531 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone"))) TS_CResult_WarningMessageDecodeErrorZ_clone(uint64_t orig) {
21532 LDKCResult_WarningMessageDecodeErrorZ* orig_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(orig);
21533 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
21534 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(orig_conv);
21535 return tag_ptr(ret_conv, true);
21538 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
21539 LDKUnsignedNodeAnnouncement o_conv;
21540 o_conv.inner = untag_ptr(o);
21541 o_conv.is_owned = ptr_is_owned(o);
21542 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21543 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
21544 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21545 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
21546 return tag_ptr(ret_conv, true);
21549 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint64_t e) {
21550 void* e_ptr = untag_ptr(e);
21551 CHECK_ACCESS(e_ptr);
21552 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21553 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21554 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21555 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
21556 return tag_ptr(ret_conv, true);
21559 jboolean __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21560 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(o);
21561 jboolean ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
21565 void __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
21566 if (!ptr_is_owned(_res)) return;
21567 void* _res_ptr = untag_ptr(_res);
21568 CHECK_ACCESS(_res_ptr);
21569 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(_res_ptr);
21570 FREE(untag_ptr(_res));
21571 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
21574 static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21575 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21576 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
21577 return tag_ptr(ret_conv, true);
21579 int64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21580 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
21581 int64_t ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21585 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21586 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
21587 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
21588 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
21589 return tag_ptr(ret_conv, true);
21592 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
21593 LDKNodeAnnouncement o_conv;
21594 o_conv.inner = untag_ptr(o);
21595 o_conv.is_owned = ptr_is_owned(o);
21596 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21597 o_conv = NodeAnnouncement_clone(&o_conv);
21598 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21599 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
21600 return tag_ptr(ret_conv, true);
21603 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint64_t e) {
21604 void* e_ptr = untag_ptr(e);
21605 CHECK_ACCESS(e_ptr);
21606 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21607 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21608 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21609 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
21610 return tag_ptr(ret_conv, true);
21613 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
21614 LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(o);
21615 jboolean ret_conv = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
21619 void __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
21620 if (!ptr_is_owned(_res)) return;
21621 void* _res_ptr = untag_ptr(_res);
21622 CHECK_ACCESS(_res_ptr);
21623 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(_res_ptr);
21624 FREE(untag_ptr(_res));
21625 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
21628 static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
21629 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21630 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
21631 return tag_ptr(ret_conv, true);
21633 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
21634 LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
21635 int64_t ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
21639 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
21640 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
21641 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
21642 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
21643 return tag_ptr(ret_conv, true);
21646 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint64_t o) {
21647 LDKQueryShortChannelIds o_conv;
21648 o_conv.inner = untag_ptr(o);
21649 o_conv.is_owned = ptr_is_owned(o);
21650 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21651 o_conv = QueryShortChannelIds_clone(&o_conv);
21652 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21653 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
21654 return tag_ptr(ret_conv, true);
21657 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint64_t e) {
21658 void* e_ptr = untag_ptr(e);
21659 CHECK_ACCESS(e_ptr);
21660 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21661 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21662 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21663 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
21664 return tag_ptr(ret_conv, true);
21667 jboolean __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint64_t o) {
21668 LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(o);
21669 jboolean ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
21673 void __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_free"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint64_t _res) {
21674 if (!ptr_is_owned(_res)) return;
21675 void* _res_ptr = untag_ptr(_res);
21676 CHECK_ACCESS(_res_ptr);
21677 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(_res_ptr);
21678 FREE(untag_ptr(_res));
21679 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
21682 static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
21683 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21684 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
21685 return tag_ptr(ret_conv, true);
21687 int64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint64_t arg) {
21688 LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(arg);
21689 int64_t ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
21693 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint64_t orig) {
21694 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(orig);
21695 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
21696 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
21697 return tag_ptr(ret_conv, true);
21700 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint64_t o) {
21701 LDKReplyShortChannelIdsEnd o_conv;
21702 o_conv.inner = untag_ptr(o);
21703 o_conv.is_owned = ptr_is_owned(o);
21704 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21705 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
21706 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21707 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
21708 return tag_ptr(ret_conv, true);
21711 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint64_t e) {
21712 void* e_ptr = untag_ptr(e);
21713 CHECK_ACCESS(e_ptr);
21714 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21715 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21716 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21717 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
21718 return tag_ptr(ret_conv, true);
21721 jboolean __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint64_t o) {
21722 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(o);
21723 jboolean ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
21727 void __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint64_t _res) {
21728 if (!ptr_is_owned(_res)) return;
21729 void* _res_ptr = untag_ptr(_res);
21730 CHECK_ACCESS(_res_ptr);
21731 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(_res_ptr);
21732 FREE(untag_ptr(_res));
21733 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
21736 static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
21737 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21738 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
21739 return tag_ptr(ret_conv, true);
21741 int64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint64_t arg) {
21742 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(arg);
21743 int64_t ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
21747 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint64_t orig) {
21748 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(orig);
21749 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
21750 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
21751 return tag_ptr(ret_conv, true);
21754 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint64_t o) {
21755 LDKQueryChannelRange o_conv;
21756 o_conv.inner = untag_ptr(o);
21757 o_conv.is_owned = ptr_is_owned(o);
21758 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21759 o_conv = QueryChannelRange_clone(&o_conv);
21760 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21761 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
21762 return tag_ptr(ret_conv, true);
21765 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint64_t e) {
21766 void* e_ptr = untag_ptr(e);
21767 CHECK_ACCESS(e_ptr);
21768 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21769 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21770 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21771 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
21772 return tag_ptr(ret_conv, true);
21775 jboolean __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
21776 LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(o);
21777 jboolean ret_conv = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
21781 void __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_free"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint64_t _res) {
21782 if (!ptr_is_owned(_res)) return;
21783 void* _res_ptr = untag_ptr(_res);
21784 CHECK_ACCESS(_res_ptr);
21785 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(_res_ptr);
21786 FREE(untag_ptr(_res));
21787 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
21790 static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
21791 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21792 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
21793 return tag_ptr(ret_conv, true);
21795 int64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
21796 LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(arg);
21797 int64_t ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
21801 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint64_t orig) {
21802 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(orig);
21803 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
21804 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
21805 return tag_ptr(ret_conv, true);
21808 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint64_t o) {
21809 LDKReplyChannelRange o_conv;
21810 o_conv.inner = untag_ptr(o);
21811 o_conv.is_owned = ptr_is_owned(o);
21812 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21813 o_conv = ReplyChannelRange_clone(&o_conv);
21814 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21815 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
21816 return tag_ptr(ret_conv, true);
21819 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint64_t e) {
21820 void* e_ptr = untag_ptr(e);
21821 CHECK_ACCESS(e_ptr);
21822 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21823 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21824 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21825 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
21826 return tag_ptr(ret_conv, true);
21829 jboolean __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
21830 LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(o);
21831 jboolean ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
21835 void __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_free"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint64_t _res) {
21836 if (!ptr_is_owned(_res)) return;
21837 void* _res_ptr = untag_ptr(_res);
21838 CHECK_ACCESS(_res_ptr);
21839 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(_res_ptr);
21840 FREE(untag_ptr(_res));
21841 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
21844 static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
21845 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21846 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
21847 return tag_ptr(ret_conv, true);
21849 int64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
21850 LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(arg);
21851 int64_t ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
21855 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint64_t orig) {
21856 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(orig);
21857 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
21858 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
21859 return tag_ptr(ret_conv, true);
21862 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint64_t o) {
21863 LDKGossipTimestampFilter o_conv;
21864 o_conv.inner = untag_ptr(o);
21865 o_conv.is_owned = ptr_is_owned(o);
21866 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21867 o_conv = GossipTimestampFilter_clone(&o_conv);
21868 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21869 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
21870 return tag_ptr(ret_conv, true);
21873 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint64_t e) {
21874 void* e_ptr = untag_ptr(e);
21875 CHECK_ACCESS(e_ptr);
21876 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21877 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21878 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21879 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
21880 return tag_ptr(ret_conv, true);
21883 jboolean __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint64_t o) {
21884 LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(o);
21885 jboolean ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
21889 void __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_free"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint64_t _res) {
21890 if (!ptr_is_owned(_res)) return;
21891 void* _res_ptr = untag_ptr(_res);
21892 CHECK_ACCESS(_res_ptr);
21893 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(_res_ptr);
21894 FREE(untag_ptr(_res));
21895 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
21898 static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
21899 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21900 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
21901 return tag_ptr(ret_conv, true);
21903 int64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint64_t arg) {
21904 LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(arg);
21905 int64_t ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
21909 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint64_t orig) {
21910 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(orig);
21911 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
21912 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
21913 return tag_ptr(ret_conv, true);
21916 uint64_t __attribute__((export_name("TS_COption_FilterZ_some"))) TS_COption_FilterZ_some(uint64_t o) {
21917 void* o_ptr = untag_ptr(o);
21918 CHECK_ACCESS(o_ptr);
21919 LDKFilter o_conv = *(LDKFilter*)(o_ptr);
21920 if (o_conv.free == LDKFilter_JCalls_free) {
21921 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21922 LDKFilter_JCalls_cloned(&o_conv);
21924 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
21925 *ret_copy = COption_FilterZ_some(o_conv);
21926 uint64_t ret_ref = tag_ptr(ret_copy, true);
21930 uint64_t __attribute__((export_name("TS_COption_FilterZ_none"))) TS_COption_FilterZ_none() {
21931 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
21932 *ret_copy = COption_FilterZ_none();
21933 uint64_t ret_ref = tag_ptr(ret_copy, true);
21937 void __attribute__((export_name("TS_COption_FilterZ_free"))) TS_COption_FilterZ_free(uint64_t _res) {
21938 if (!ptr_is_owned(_res)) return;
21939 void* _res_ptr = untag_ptr(_res);
21940 CHECK_ACCESS(_res_ptr);
21941 LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(_res_ptr);
21942 FREE(untag_ptr(_res));
21943 COption_FilterZ_free(_res_conv);
21946 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_ok"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint64_t o) {
21947 LDKLockedChannelMonitor o_conv;
21948 o_conv.inner = untag_ptr(o);
21949 o_conv.is_owned = ptr_is_owned(o);
21950 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21951 // WARNING: we need a move here but no clone is available for LDKLockedChannelMonitor
21953 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
21954 *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
21955 return tag_ptr(ret_conv, true);
21958 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_err"))) TS_CResult_LockedChannelMonitorNoneZ_err() {
21959 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
21960 *ret_conv = CResult_LockedChannelMonitorNoneZ_err();
21961 return tag_ptr(ret_conv, true);
21964 jboolean __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_is_ok"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint64_t o) {
21965 LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(o);
21966 jboolean ret_conv = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
21970 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_free"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint64_t _res) {
21971 if (!ptr_is_owned(_res)) return;
21972 void* _res_ptr = untag_ptr(_res);
21973 CHECK_ACCESS(_res_ptr);
21974 LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(_res_ptr);
21975 FREE(untag_ptr(_res));
21976 CResult_LockedChannelMonitorNoneZ_free(_res_conv);
21979 void __attribute__((export_name("TS_CVec_OutPointZ_free"))) TS_CVec_OutPointZ_free(uint64_tArray _res) {
21980 LDKCVec_OutPointZ _res_constr;
21981 _res_constr.datalen = _res->arr_len;
21982 if (_res_constr.datalen > 0)
21983 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements");
21985 _res_constr.data = NULL;
21986 uint64_t* _res_vals = _res->elems;
21987 for (size_t k = 0; k < _res_constr.datalen; k++) {
21988 uint64_t _res_conv_10 = _res_vals[k];
21989 LDKOutPoint _res_conv_10_conv;
21990 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
21991 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
21992 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
21993 _res_constr.data[k] = _res_conv_10_conv;
21996 CVec_OutPointZ_free(_res_constr);
21999 void __attribute__((export_name("TS_CVec_MonitorUpdateIdZ_free"))) TS_CVec_MonitorUpdateIdZ_free(uint64_tArray _res) {
22000 LDKCVec_MonitorUpdateIdZ _res_constr;
22001 _res_constr.datalen = _res->arr_len;
22002 if (_res_constr.datalen > 0)
22003 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
22005 _res_constr.data = NULL;
22006 uint64_t* _res_vals = _res->elems;
22007 for (size_t r = 0; r < _res_constr.datalen; r++) {
22008 uint64_t _res_conv_17 = _res_vals[r];
22009 LDKMonitorUpdateId _res_conv_17_conv;
22010 _res_conv_17_conv.inner = untag_ptr(_res_conv_17);
22011 _res_conv_17_conv.is_owned = ptr_is_owned(_res_conv_17);
22012 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_17_conv);
22013 _res_constr.data[r] = _res_conv_17_conv;
22016 CVec_MonitorUpdateIdZ_free(_res_constr);
22019 static inline uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg) {
22020 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
22021 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(arg);
22022 return tag_ptr(ret_conv, true);
22024 int64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(uint64_t arg) {
22025 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* arg_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(arg);
22026 int64_t ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg_conv);
22030 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(uint64_t orig) {
22031 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* orig_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(orig);
22032 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
22033 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig_conv);
22034 return tag_ptr(ret_conv, true);
22037 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(uint64_t a, uint64_tArray b) {
22038 LDKOutPoint a_conv;
22039 a_conv.inner = untag_ptr(a);
22040 a_conv.is_owned = ptr_is_owned(a);
22041 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22042 a_conv = OutPoint_clone(&a_conv);
22043 LDKCVec_MonitorUpdateIdZ b_constr;
22044 b_constr.datalen = b->arr_len;
22045 if (b_constr.datalen > 0)
22046 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
22048 b_constr.data = NULL;
22049 uint64_t* b_vals = b->elems;
22050 for (size_t r = 0; r < b_constr.datalen; r++) {
22051 uint64_t b_conv_17 = b_vals[r];
22052 LDKMonitorUpdateId b_conv_17_conv;
22053 b_conv_17_conv.inner = untag_ptr(b_conv_17);
22054 b_conv_17_conv.is_owned = ptr_is_owned(b_conv_17);
22055 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv_17_conv);
22056 b_conv_17_conv = MonitorUpdateId_clone(&b_conv_17_conv);
22057 b_constr.data[r] = b_conv_17_conv;
22060 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
22061 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a_conv, b_constr);
22062 return tag_ptr(ret_conv, true);
22065 void __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(uint64_t _res) {
22066 if (!ptr_is_owned(_res)) return;
22067 void* _res_ptr = untag_ptr(_res);
22068 CHECK_ACCESS(_res_ptr);
22069 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_ptr);
22070 FREE(untag_ptr(_res));
22071 C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res_conv);
22074 void __attribute__((export_name("TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free"))) TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(uint64_tArray _res) {
22075 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res_constr;
22076 _res_constr.datalen = _res->arr_len;
22077 if (_res_constr.datalen > 0)
22078 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ Elements");
22080 _res_constr.data = NULL;
22081 uint64_t* _res_vals = _res->elems;
22082 for (size_t p = 0; p < _res_constr.datalen; p++) {
22083 uint64_t _res_conv_41 = _res_vals[p];
22084 void* _res_conv_41_ptr = untag_ptr(_res_conv_41);
22085 CHECK_ACCESS(_res_conv_41_ptr);
22086 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv_41_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_conv_41_ptr);
22087 FREE(untag_ptr(_res_conv_41));
22088 _res_constr.data[p] = _res_conv_41_conv;
22091 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res_constr);
22094 void __attribute__((export_name("TS_CVec_PhantomRouteHintsZ_free"))) TS_CVec_PhantomRouteHintsZ_free(uint64_tArray _res) {
22095 LDKCVec_PhantomRouteHintsZ _res_constr;
22096 _res_constr.datalen = _res->arr_len;
22097 if (_res_constr.datalen > 0)
22098 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
22100 _res_constr.data = NULL;
22101 uint64_t* _res_vals = _res->elems;
22102 for (size_t t = 0; t < _res_constr.datalen; t++) {
22103 uint64_t _res_conv_19 = _res_vals[t];
22104 LDKPhantomRouteHints _res_conv_19_conv;
22105 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
22106 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
22107 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
22108 _res_constr.data[t] = _res_conv_19_conv;
22111 CVec_PhantomRouteHintsZ_free(_res_constr);
22114 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_ok(uint64_t o) {
22116 o_conv.inner = untag_ptr(o);
22117 o_conv.is_owned = ptr_is_owned(o);
22118 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22119 o_conv = Invoice_clone(&o_conv);
22120 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22121 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
22122 return tag_ptr(ret_conv, true);
22125 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint64_t e) {
22126 void* e_ptr = untag_ptr(e);
22127 CHECK_ACCESS(e_ptr);
22128 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(e_ptr);
22129 e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)untag_ptr(e));
22130 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22131 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
22132 return tag_ptr(ret_conv, true);
22135 jboolean __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_is_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint64_t o) {
22136 LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(o);
22137 jboolean ret_conv = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
22141 void __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_free"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint64_t _res) {
22142 if (!ptr_is_owned(_res)) return;
22143 void* _res_ptr = untag_ptr(_res);
22144 CHECK_ACCESS(_res_ptr);
22145 LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(_res_ptr);
22146 FREE(untag_ptr(_res));
22147 CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
22150 static inline uint64_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
22151 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22152 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
22153 return tag_ptr(ret_conv, true);
22155 int64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint64_t arg) {
22156 LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(arg);
22157 int64_t ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
22161 uint64_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint64_t orig) {
22162 LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)untag_ptr(orig);
22163 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
22164 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
22165 return tag_ptr(ret_conv, true);
22168 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_ok"))) TS_CResult_SiPrefixParseErrorZ_ok(uint32_t o) {
22169 LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
22170 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22171 *ret_conv = CResult_SiPrefixParseErrorZ_ok(o_conv);
22172 return tag_ptr(ret_conv, true);
22175 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_err"))) TS_CResult_SiPrefixParseErrorZ_err(uint64_t e) {
22176 void* e_ptr = untag_ptr(e);
22177 CHECK_ACCESS(e_ptr);
22178 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
22179 e_conv = ParseError_clone((LDKParseError*)untag_ptr(e));
22180 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22181 *ret_conv = CResult_SiPrefixParseErrorZ_err(e_conv);
22182 return tag_ptr(ret_conv, true);
22185 jboolean __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_is_ok"))) TS_CResult_SiPrefixParseErrorZ_is_ok(uint64_t o) {
22186 LDKCResult_SiPrefixParseErrorZ* o_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(o);
22187 jboolean ret_conv = CResult_SiPrefixParseErrorZ_is_ok(o_conv);
22191 void __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_free"))) TS_CResult_SiPrefixParseErrorZ_free(uint64_t _res) {
22192 if (!ptr_is_owned(_res)) return;
22193 void* _res_ptr = untag_ptr(_res);
22194 CHECK_ACCESS(_res_ptr);
22195 LDKCResult_SiPrefixParseErrorZ _res_conv = *(LDKCResult_SiPrefixParseErrorZ*)(_res_ptr);
22196 FREE(untag_ptr(_res));
22197 CResult_SiPrefixParseErrorZ_free(_res_conv);
22200 static inline uint64_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg) {
22201 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22202 *ret_conv = CResult_SiPrefixParseErrorZ_clone(arg);
22203 return tag_ptr(ret_conv, true);
22205 int64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone_ptr"))) TS_CResult_SiPrefixParseErrorZ_clone_ptr(uint64_t arg) {
22206 LDKCResult_SiPrefixParseErrorZ* arg_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(arg);
22207 int64_t ret_conv = CResult_SiPrefixParseErrorZ_clone_ptr(arg_conv);
22211 uint64_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone"))) TS_CResult_SiPrefixParseErrorZ_clone(uint64_t orig) {
22212 LDKCResult_SiPrefixParseErrorZ* orig_conv = (LDKCResult_SiPrefixParseErrorZ*)untag_ptr(orig);
22213 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
22214 *ret_conv = CResult_SiPrefixParseErrorZ_clone(orig_conv);
22215 return tag_ptr(ret_conv, true);
22218 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_ok(uint64_t o) {
22220 o_conv.inner = untag_ptr(o);
22221 o_conv.is_owned = ptr_is_owned(o);
22222 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22223 o_conv = Invoice_clone(&o_conv);
22224 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22225 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_ok(o_conv);
22226 return tag_ptr(ret_conv, true);
22229 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_err(uint64_t e) {
22230 void* e_ptr = untag_ptr(e);
22231 CHECK_ACCESS(e_ptr);
22232 LDKParseOrSemanticError e_conv = *(LDKParseOrSemanticError*)(e_ptr);
22233 e_conv = ParseOrSemanticError_clone((LDKParseOrSemanticError*)untag_ptr(e));
22234 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22235 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_err(e_conv);
22236 return tag_ptr(ret_conv, true);
22239 jboolean __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(uint64_t o) {
22240 LDKCResult_InvoiceParseOrSemanticErrorZ* o_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(o);
22241 jboolean ret_conv = CResult_InvoiceParseOrSemanticErrorZ_is_ok(o_conv);
22245 void __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_free"))) TS_CResult_InvoiceParseOrSemanticErrorZ_free(uint64_t _res) {
22246 if (!ptr_is_owned(_res)) return;
22247 void* _res_ptr = untag_ptr(_res);
22248 CHECK_ACCESS(_res_ptr);
22249 LDKCResult_InvoiceParseOrSemanticErrorZ _res_conv = *(LDKCResult_InvoiceParseOrSemanticErrorZ*)(_res_ptr);
22250 FREE(untag_ptr(_res));
22251 CResult_InvoiceParseOrSemanticErrorZ_free(_res_conv);
22254 static inline uint64_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg) {
22255 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22256 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(arg);
22257 return tag_ptr(ret_conv, true);
22259 int64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(uint64_t arg) {
22260 LDKCResult_InvoiceParseOrSemanticErrorZ* arg_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(arg);
22261 int64_t ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg_conv);
22265 uint64_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone(uint64_t orig) {
22266 LDKCResult_InvoiceParseOrSemanticErrorZ* orig_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)untag_ptr(orig);
22267 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
22268 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(orig_conv);
22269 return tag_ptr(ret_conv, true);
22272 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_ok(uint64_t o) {
22273 LDKSignedRawInvoice o_conv;
22274 o_conv.inner = untag_ptr(o);
22275 o_conv.is_owned = ptr_is_owned(o);
22276 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22277 o_conv = SignedRawInvoice_clone(&o_conv);
22278 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22279 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_ok(o_conv);
22280 return tag_ptr(ret_conv, true);
22283 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_err(uint64_t e) {
22284 void* e_ptr = untag_ptr(e);
22285 CHECK_ACCESS(e_ptr);
22286 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
22287 e_conv = ParseError_clone((LDKParseError*)untag_ptr(e));
22288 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22289 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_err(e_conv);
22290 return tag_ptr(ret_conv, true);
22293 jboolean __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_is_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(uint64_t o) {
22294 LDKCResult_SignedRawInvoiceParseErrorZ* o_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(o);
22295 jboolean ret_conv = CResult_SignedRawInvoiceParseErrorZ_is_ok(o_conv);
22299 void __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_free"))) TS_CResult_SignedRawInvoiceParseErrorZ_free(uint64_t _res) {
22300 if (!ptr_is_owned(_res)) return;
22301 void* _res_ptr = untag_ptr(_res);
22302 CHECK_ACCESS(_res_ptr);
22303 LDKCResult_SignedRawInvoiceParseErrorZ _res_conv = *(LDKCResult_SignedRawInvoiceParseErrorZ*)(_res_ptr);
22304 FREE(untag_ptr(_res));
22305 CResult_SignedRawInvoiceParseErrorZ_free(_res_conv);
22308 static inline uint64_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg) {
22309 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22310 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(arg);
22311 return tag_ptr(ret_conv, true);
22313 int64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(uint64_t arg) {
22314 LDKCResult_SignedRawInvoiceParseErrorZ* arg_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(arg);
22315 int64_t ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg_conv);
22319 uint64_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone(uint64_t orig) {
22320 LDKCResult_SignedRawInvoiceParseErrorZ* orig_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)untag_ptr(orig);
22321 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
22322 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(orig_conv);
22323 return tag_ptr(ret_conv, true);
22326 static inline uint64_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
22327 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22328 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
22329 return tag_ptr(ret_conv, true);
22331 int64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint64_t arg) {
22332 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(arg);
22333 int64_t ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
22337 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint64_t orig) {
22338 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)untag_ptr(orig);
22339 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22340 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
22341 return tag_ptr(ret_conv, true);
22344 uint64_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint64_t a, int8_tArray b, uint64_t c) {
22345 LDKRawInvoice a_conv;
22346 a_conv.inner = untag_ptr(a);
22347 a_conv.is_owned = ptr_is_owned(a);
22348 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22349 a_conv = RawInvoice_clone(&a_conv);
22350 LDKThirtyTwoBytes b_ref;
22351 CHECK(b->arr_len == 32);
22352 memcpy(b_ref.data, b->elems, 32); FREE(b);
22353 LDKInvoiceSignature c_conv;
22354 c_conv.inner = untag_ptr(c);
22355 c_conv.is_owned = ptr_is_owned(c);
22356 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
22357 c_conv = InvoiceSignature_clone(&c_conv);
22358 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22359 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
22360 return tag_ptr(ret_conv, true);
22363 void __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint64_t _res) {
22364 if (!ptr_is_owned(_res)) return;
22365 void* _res_ptr = untag_ptr(_res);
22366 CHECK_ACCESS(_res_ptr);
22367 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(_res_ptr);
22368 FREE(untag_ptr(_res));
22369 C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
22372 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_ok"))) TS_CResult_PayeePubKeyErrorZ_ok(uint64_t o) {
22373 LDKPayeePubKey o_conv;
22374 o_conv.inner = untag_ptr(o);
22375 o_conv.is_owned = ptr_is_owned(o);
22376 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22377 o_conv = PayeePubKey_clone(&o_conv);
22378 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22379 *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
22380 return tag_ptr(ret_conv, true);
22383 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_err"))) TS_CResult_PayeePubKeyErrorZ_err(uint32_t e) {
22384 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
22385 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22386 *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
22387 return tag_ptr(ret_conv, true);
22390 jboolean __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_is_ok"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint64_t o) {
22391 LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(o);
22392 jboolean ret_conv = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
22396 void __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_free"))) TS_CResult_PayeePubKeyErrorZ_free(uint64_t _res) {
22397 if (!ptr_is_owned(_res)) return;
22398 void* _res_ptr = untag_ptr(_res);
22399 CHECK_ACCESS(_res_ptr);
22400 LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(_res_ptr);
22401 FREE(untag_ptr(_res));
22402 CResult_PayeePubKeyErrorZ_free(_res_conv);
22405 static inline uint64_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
22406 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22407 *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
22408 return tag_ptr(ret_conv, true);
22410 int64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone_ptr"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint64_t arg) {
22411 LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(arg);
22412 int64_t ret_conv = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
22416 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone"))) TS_CResult_PayeePubKeyErrorZ_clone(uint64_t orig) {
22417 LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)untag_ptr(orig);
22418 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22419 *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
22420 return tag_ptr(ret_conv, true);
22423 void __attribute__((export_name("TS_CVec_PrivateRouteZ_free"))) TS_CVec_PrivateRouteZ_free(uint64_tArray _res) {
22424 LDKCVec_PrivateRouteZ _res_constr;
22425 _res_constr.datalen = _res->arr_len;
22426 if (_res_constr.datalen > 0)
22427 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
22429 _res_constr.data = NULL;
22430 uint64_t* _res_vals = _res->elems;
22431 for (size_t o = 0; o < _res_constr.datalen; o++) {
22432 uint64_t _res_conv_14 = _res_vals[o];
22433 LDKPrivateRoute _res_conv_14_conv;
22434 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
22435 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
22436 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
22437 _res_constr.data[o] = _res_conv_14_conv;
22440 CVec_PrivateRouteZ_free(_res_constr);
22443 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint64_t o) {
22444 LDKPositiveTimestamp o_conv;
22445 o_conv.inner = untag_ptr(o);
22446 o_conv.is_owned = ptr_is_owned(o);
22447 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22448 o_conv = PositiveTimestamp_clone(&o_conv);
22449 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22450 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
22451 return tag_ptr(ret_conv, true);
22454 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_err"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
22455 LDKCreationError e_conv = LDKCreationError_from_js(e);
22456 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22457 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
22458 return tag_ptr(ret_conv, true);
22461 jboolean __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_is_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint64_t o) {
22462 LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(o);
22463 jboolean ret_conv = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
22467 void __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_free"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint64_t _res) {
22468 if (!ptr_is_owned(_res)) return;
22469 void* _res_ptr = untag_ptr(_res);
22470 CHECK_ACCESS(_res_ptr);
22471 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(_res_ptr);
22472 FREE(untag_ptr(_res));
22473 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
22476 static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
22477 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22478 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
22479 return tag_ptr(ret_conv, true);
22481 int64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint64_t arg) {
22482 LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(arg);
22483 int64_t ret_conv = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
22487 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint64_t orig) {
22488 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(orig);
22489 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22490 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
22491 return tag_ptr(ret_conv, true);
22494 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_ok"))) TS_CResult_NoneSemanticErrorZ_ok() {
22495 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22496 *ret_conv = CResult_NoneSemanticErrorZ_ok();
22497 return tag_ptr(ret_conv, true);
22500 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_err"))) TS_CResult_NoneSemanticErrorZ_err(uint32_t e) {
22501 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
22502 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22503 *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
22504 return tag_ptr(ret_conv, true);
22507 jboolean __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_is_ok"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint64_t o) {
22508 LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(o);
22509 jboolean ret_conv = CResult_NoneSemanticErrorZ_is_ok(o_conv);
22513 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_free"))) TS_CResult_NoneSemanticErrorZ_free(uint64_t _res) {
22514 if (!ptr_is_owned(_res)) return;
22515 void* _res_ptr = untag_ptr(_res);
22516 CHECK_ACCESS(_res_ptr);
22517 LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(_res_ptr);
22518 FREE(untag_ptr(_res));
22519 CResult_NoneSemanticErrorZ_free(_res_conv);
22522 static inline uint64_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
22523 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22524 *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
22525 return tag_ptr(ret_conv, true);
22527 int64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone_ptr"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint64_t arg) {
22528 LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(arg);
22529 int64_t ret_conv = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
22533 uint64_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone"))) TS_CResult_NoneSemanticErrorZ_clone(uint64_t orig) {
22534 LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)untag_ptr(orig);
22535 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22536 *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
22537 return tag_ptr(ret_conv, true);
22540 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_ok"))) TS_CResult_InvoiceSemanticErrorZ_ok(uint64_t o) {
22542 o_conv.inner = untag_ptr(o);
22543 o_conv.is_owned = ptr_is_owned(o);
22544 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22545 o_conv = Invoice_clone(&o_conv);
22546 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22547 *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
22548 return tag_ptr(ret_conv, true);
22551 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_err"))) TS_CResult_InvoiceSemanticErrorZ_err(uint32_t e) {
22552 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
22553 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22554 *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
22555 return tag_ptr(ret_conv, true);
22558 jboolean __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_is_ok"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint64_t o) {
22559 LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(o);
22560 jboolean ret_conv = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
22564 void __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_free"))) TS_CResult_InvoiceSemanticErrorZ_free(uint64_t _res) {
22565 if (!ptr_is_owned(_res)) return;
22566 void* _res_ptr = untag_ptr(_res);
22567 CHECK_ACCESS(_res_ptr);
22568 LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(_res_ptr);
22569 FREE(untag_ptr(_res));
22570 CResult_InvoiceSemanticErrorZ_free(_res_conv);
22573 static inline uint64_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
22574 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22575 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
22576 return tag_ptr(ret_conv, true);
22578 int64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint64_t arg) {
22579 LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(arg);
22580 int64_t ret_conv = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
22584 uint64_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint64_t orig) {
22585 LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)untag_ptr(orig);
22586 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22587 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
22588 return tag_ptr(ret_conv, true);
22591 void __attribute__((export_name("TS_CVec_AddressZ_free"))) TS_CVec_AddressZ_free(ptrArray _res) {
22592 LDKCVec_AddressZ _res_constr;
22593 _res_constr.datalen = _res->arr_len;
22594 if (_res_constr.datalen > 0)
22595 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKStr), "LDKCVec_AddressZ Elements");
22597 _res_constr.data = NULL;
22598 jstring* _res_vals = (void*) _res->elems;
22599 for (size_t i = 0; i < _res_constr.datalen; i++) {
22600 jstring _res_conv_8 = _res_vals[i];
22601 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
22602 _res_constr.data[i] = dummy;
22605 CVec_AddressZ_free(_res_constr);
22608 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_ok"))) TS_CResult_DescriptionCreationErrorZ_ok(uint64_t o) {
22609 LDKDescription o_conv;
22610 o_conv.inner = untag_ptr(o);
22611 o_conv.is_owned = ptr_is_owned(o);
22612 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22613 o_conv = Description_clone(&o_conv);
22614 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22615 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
22616 return tag_ptr(ret_conv, true);
22619 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_err"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
22620 LDKCreationError e_conv = LDKCreationError_from_js(e);
22621 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22622 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
22623 return tag_ptr(ret_conv, true);
22626 jboolean __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_is_ok"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint64_t o) {
22627 LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(o);
22628 jboolean ret_conv = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
22632 void __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_free"))) TS_CResult_DescriptionCreationErrorZ_free(uint64_t _res) {
22633 if (!ptr_is_owned(_res)) return;
22634 void* _res_ptr = untag_ptr(_res);
22635 CHECK_ACCESS(_res_ptr);
22636 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(_res_ptr);
22637 FREE(untag_ptr(_res));
22638 CResult_DescriptionCreationErrorZ_free(_res_conv);
22641 static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
22642 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22643 *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
22644 return tag_ptr(ret_conv, true);
22646 int64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone_ptr"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint64_t arg) {
22647 LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(arg);
22648 int64_t ret_conv = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
22652 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone"))) TS_CResult_DescriptionCreationErrorZ_clone(uint64_t orig) {
22653 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(orig);
22654 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
22655 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
22656 return tag_ptr(ret_conv, true);
22659 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_ok"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint64_t o) {
22660 LDKPrivateRoute o_conv;
22661 o_conv.inner = untag_ptr(o);
22662 o_conv.is_owned = ptr_is_owned(o);
22663 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22664 o_conv = PrivateRoute_clone(&o_conv);
22665 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22666 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
22667 return tag_ptr(ret_conv, true);
22670 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_err"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
22671 LDKCreationError e_conv = LDKCreationError_from_js(e);
22672 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22673 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
22674 return tag_ptr(ret_conv, true);
22677 jboolean __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_is_ok"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint64_t o) {
22678 LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(o);
22679 jboolean ret_conv = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
22683 void __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_free"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint64_t _res) {
22684 if (!ptr_is_owned(_res)) return;
22685 void* _res_ptr = untag_ptr(_res);
22686 CHECK_ACCESS(_res_ptr);
22687 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(_res_ptr);
22688 FREE(untag_ptr(_res));
22689 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
22692 static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
22693 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22694 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
22695 return tag_ptr(ret_conv, true);
22697 int64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone_ptr"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint64_t arg) {
22698 LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(arg);
22699 int64_t ret_conv = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
22703 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint64_t orig) {
22704 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(orig);
22705 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
22706 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
22707 return tag_ptr(ret_conv, true);
22710 void __attribute__((export_name("TS_APIError_free"))) TS_APIError_free(uint64_t this_ptr) {
22711 if (!ptr_is_owned(this_ptr)) return;
22712 void* this_ptr_ptr = untag_ptr(this_ptr);
22713 CHECK_ACCESS(this_ptr_ptr);
22714 LDKAPIError this_ptr_conv = *(LDKAPIError*)(this_ptr_ptr);
22715 FREE(untag_ptr(this_ptr));
22716 APIError_free(this_ptr_conv);
22719 static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
22720 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22721 *ret_copy = APIError_clone(arg);
22722 uint64_t ret_ref = tag_ptr(ret_copy, true);
22725 int64_t __attribute__((export_name("TS_APIError_clone_ptr"))) TS_APIError_clone_ptr(uint64_t arg) {
22726 LDKAPIError* arg_conv = (LDKAPIError*)untag_ptr(arg);
22727 int64_t ret_conv = APIError_clone_ptr(arg_conv);
22731 uint64_t __attribute__((export_name("TS_APIError_clone"))) TS_APIError_clone(uint64_t orig) {
22732 LDKAPIError* orig_conv = (LDKAPIError*)untag_ptr(orig);
22733 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22734 *ret_copy = APIError_clone(orig_conv);
22735 uint64_t ret_ref = tag_ptr(ret_copy, true);
22739 uint64_t __attribute__((export_name("TS_APIError_apimisuse_error"))) TS_APIError_apimisuse_error(jstring err) {
22740 LDKStr err_conv = str_ref_to_owned_c(err);
22741 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22742 *ret_copy = APIError_apimisuse_error(err_conv);
22743 uint64_t ret_ref = tag_ptr(ret_copy, true);
22747 uint64_t __attribute__((export_name("TS_APIError_fee_rate_too_high"))) TS_APIError_fee_rate_too_high(jstring err, int32_t feerate) {
22748 LDKStr err_conv = str_ref_to_owned_c(err);
22749 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22750 *ret_copy = APIError_fee_rate_too_high(err_conv, feerate);
22751 uint64_t ret_ref = tag_ptr(ret_copy, true);
22755 uint64_t __attribute__((export_name("TS_APIError_invalid_route"))) TS_APIError_invalid_route(jstring err) {
22756 LDKStr err_conv = str_ref_to_owned_c(err);
22757 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22758 *ret_copy = APIError_invalid_route(err_conv);
22759 uint64_t ret_ref = tag_ptr(ret_copy, true);
22763 uint64_t __attribute__((export_name("TS_APIError_channel_unavailable"))) TS_APIError_channel_unavailable(jstring err) {
22764 LDKStr err_conv = str_ref_to_owned_c(err);
22765 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22766 *ret_copy = APIError_channel_unavailable(err_conv);
22767 uint64_t ret_ref = tag_ptr(ret_copy, true);
22771 uint64_t __attribute__((export_name("TS_APIError_monitor_update_in_progress"))) TS_APIError_monitor_update_in_progress() {
22772 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22773 *ret_copy = APIError_monitor_update_in_progress();
22774 uint64_t ret_ref = tag_ptr(ret_copy, true);
22778 uint64_t __attribute__((export_name("TS_APIError_incompatible_shutdown_script"))) TS_APIError_incompatible_shutdown_script(uint64_t script) {
22779 LDKShutdownScript script_conv;
22780 script_conv.inner = untag_ptr(script);
22781 script_conv.is_owned = ptr_is_owned(script);
22782 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
22783 script_conv = ShutdownScript_clone(&script_conv);
22784 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
22785 *ret_copy = APIError_incompatible_shutdown_script(script_conv);
22786 uint64_t ret_ref = tag_ptr(ret_copy, true);
22790 jboolean __attribute__((export_name("TS_APIError_eq"))) TS_APIError_eq(uint64_t a, uint64_t b) {
22791 LDKAPIError* a_conv = (LDKAPIError*)untag_ptr(a);
22792 LDKAPIError* b_conv = (LDKAPIError*)untag_ptr(b);
22793 jboolean ret_conv = APIError_eq(a_conv, b_conv);
22797 int8_tArray __attribute__((export_name("TS_APIError_write"))) TS_APIError_write(uint64_t obj) {
22798 LDKAPIError* obj_conv = (LDKAPIError*)untag_ptr(obj);
22799 LDKCVec_u8Z ret_var = APIError_write(obj_conv);
22800 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22801 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22802 CVec_u8Z_free(ret_var);
22806 uint64_t __attribute__((export_name("TS_APIError_read"))) TS_APIError_read(int8_tArray ser) {
22807 LDKu8slice ser_ref;
22808 ser_ref.datalen = ser->arr_len;
22809 ser_ref.data = ser->elems;
22810 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
22811 *ret_conv = APIError_read(ser_ref);
22813 return tag_ptr(ret_conv, true);
22816 void __attribute__((export_name("TS_BigSize_free"))) TS_BigSize_free(uint64_t this_obj) {
22817 LDKBigSize this_obj_conv;
22818 this_obj_conv.inner = untag_ptr(this_obj);
22819 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22820 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22821 BigSize_free(this_obj_conv);
22824 int64_t __attribute__((export_name("TS_BigSize_get_a"))) TS_BigSize_get_a(uint64_t this_ptr) {
22825 LDKBigSize this_ptr_conv;
22826 this_ptr_conv.inner = untag_ptr(this_ptr);
22827 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22828 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22829 this_ptr_conv.is_owned = false;
22830 int64_t ret_conv = BigSize_get_a(&this_ptr_conv);
22834 void __attribute__((export_name("TS_BigSize_set_a"))) TS_BigSize_set_a(uint64_t this_ptr, int64_t val) {
22835 LDKBigSize this_ptr_conv;
22836 this_ptr_conv.inner = untag_ptr(this_ptr);
22837 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22839 this_ptr_conv.is_owned = false;
22840 BigSize_set_a(&this_ptr_conv, val);
22843 uint64_t __attribute__((export_name("TS_BigSize_new"))) TS_BigSize_new(int64_t a_arg) {
22844 LDKBigSize ret_var = BigSize_new(a_arg);
22845 uint64_t ret_ref = 0;
22846 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22847 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22851 void __attribute__((export_name("TS_Hostname_free"))) TS_Hostname_free(uint64_t this_obj) {
22852 LDKHostname this_obj_conv;
22853 this_obj_conv.inner = untag_ptr(this_obj);
22854 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22856 Hostname_free(this_obj_conv);
22859 static inline uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg) {
22860 LDKHostname ret_var = Hostname_clone(arg);
22861 uint64_t ret_ref = 0;
22862 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22863 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22866 int64_t __attribute__((export_name("TS_Hostname_clone_ptr"))) TS_Hostname_clone_ptr(uint64_t arg) {
22867 LDKHostname arg_conv;
22868 arg_conv.inner = untag_ptr(arg);
22869 arg_conv.is_owned = ptr_is_owned(arg);
22870 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22871 arg_conv.is_owned = false;
22872 int64_t ret_conv = Hostname_clone_ptr(&arg_conv);
22876 uint64_t __attribute__((export_name("TS_Hostname_clone"))) TS_Hostname_clone(uint64_t orig) {
22877 LDKHostname orig_conv;
22878 orig_conv.inner = untag_ptr(orig);
22879 orig_conv.is_owned = ptr_is_owned(orig);
22880 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22881 orig_conv.is_owned = false;
22882 LDKHostname ret_var = Hostname_clone(&orig_conv);
22883 uint64_t ret_ref = 0;
22884 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22885 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
22889 jboolean __attribute__((export_name("TS_Hostname_eq"))) TS_Hostname_eq(uint64_t a, uint64_t b) {
22890 LDKHostname a_conv;
22891 a_conv.inner = untag_ptr(a);
22892 a_conv.is_owned = ptr_is_owned(a);
22893 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
22894 a_conv.is_owned = false;
22895 LDKHostname b_conv;
22896 b_conv.inner = untag_ptr(b);
22897 b_conv.is_owned = ptr_is_owned(b);
22898 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
22899 b_conv.is_owned = false;
22900 jboolean ret_conv = Hostname_eq(&a_conv, &b_conv);
22904 int8_t __attribute__((export_name("TS_Hostname_len"))) TS_Hostname_len(uint64_t this_arg) {
22905 LDKHostname this_arg_conv;
22906 this_arg_conv.inner = untag_ptr(this_arg);
22907 this_arg_conv.is_owned = ptr_is_owned(this_arg);
22908 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
22909 this_arg_conv.is_owned = false;
22910 int8_t ret_conv = Hostname_len(&this_arg_conv);
22914 uint64_t __attribute__((export_name("TS_sign"))) TS_sign(int8_tArray msg, int8_tArray sk) {
22915 LDKu8slice msg_ref;
22916 msg_ref.datalen = msg->arr_len;
22917 msg_ref.data = msg->elems;
22918 uint8_t sk_arr[32];
22919 CHECK(sk->arr_len == 32);
22920 memcpy(sk_arr, sk->elems, 32); FREE(sk);
22921 uint8_t (*sk_ref)[32] = &sk_arr;
22922 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
22923 *ret_conv = sign(msg_ref, sk_ref);
22925 return tag_ptr(ret_conv, true);
22928 uint64_t __attribute__((export_name("TS_recover_pk"))) TS_recover_pk(int8_tArray msg, jstring sig) {
22929 LDKu8slice msg_ref;
22930 msg_ref.datalen = msg->arr_len;
22931 msg_ref.data = msg->elems;
22932 LDKStr sig_conv = str_ref_to_owned_c(sig);
22933 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
22934 *ret_conv = recover_pk(msg_ref, sig_conv);
22936 return tag_ptr(ret_conv, true);
22939 jboolean __attribute__((export_name("TS_verify"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
22940 LDKu8slice msg_ref;
22941 msg_ref.datalen = msg->arr_len;
22942 msg_ref.data = msg->elems;
22943 LDKStr sig_conv = str_ref_to_owned_c(sig);
22944 LDKPublicKey pk_ref;
22945 CHECK(pk->arr_len == 33);
22946 memcpy(pk_ref.compressed_form, pk->elems, 33); FREE(pk);
22947 jboolean ret_conv = verify(msg_ref, sig_conv, pk_ref);
22952 int8_tArray __attribute__((export_name("TS_construct_invoice_preimage"))) TS_construct_invoice_preimage(int8_tArray hrp_bytes, ptrArray data_without_signature) {
22953 LDKu8slice hrp_bytes_ref;
22954 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
22955 hrp_bytes_ref.data = hrp_bytes->elems;
22956 LDKCVec_U5Z data_without_signature_constr;
22957 data_without_signature_constr.datalen = data_without_signature->arr_len;
22958 if (data_without_signature_constr.datalen > 0)
22959 data_without_signature_constr.data = MALLOC(data_without_signature_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
22961 data_without_signature_constr.data = NULL;
22962 int8_t* data_without_signature_vals = (void*) data_without_signature->elems;
22963 for (size_t h = 0; h < data_without_signature_constr.datalen; h++) {
22964 int8_t data_without_signature_conv_7 = data_without_signature_vals[h];
22966 data_without_signature_constr.data[h] = (LDKU5){ ._0 = data_without_signature_conv_7 };
22968 FREE(data_without_signature);
22969 LDKCVec_u8Z ret_var = construct_invoice_preimage(hrp_bytes_ref, data_without_signature_constr);
22970 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22971 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22972 CVec_u8Z_free(ret_var);
22977 void __attribute__((export_name("TS_Persister_free"))) TS_Persister_free(uint64_t this_ptr) {
22978 if (!ptr_is_owned(this_ptr)) return;
22979 void* this_ptr_ptr = untag_ptr(this_ptr);
22980 CHECK_ACCESS(this_ptr_ptr);
22981 LDKPersister this_ptr_conv = *(LDKPersister*)(this_ptr_ptr);
22982 FREE(untag_ptr(this_ptr));
22983 Persister_free(this_ptr_conv);
22986 void __attribute__((export_name("TS_UntrustedString_free"))) TS_UntrustedString_free(uint64_t this_obj) {
22987 LDKUntrustedString this_obj_conv;
22988 this_obj_conv.inner = untag_ptr(this_obj);
22989 this_obj_conv.is_owned = ptr_is_owned(this_obj);
22990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22991 UntrustedString_free(this_obj_conv);
22994 jstring __attribute__((export_name("TS_UntrustedString_get_a"))) TS_UntrustedString_get_a(uint64_t this_ptr) {
22995 LDKUntrustedString this_ptr_conv;
22996 this_ptr_conv.inner = untag_ptr(this_ptr);
22997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
22998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22999 this_ptr_conv.is_owned = false;
23000 LDKStr ret_str = UntrustedString_get_a(&this_ptr_conv);
23001 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23006 void __attribute__((export_name("TS_UntrustedString_set_a"))) TS_UntrustedString_set_a(uint64_t this_ptr, jstring val) {
23007 LDKUntrustedString this_ptr_conv;
23008 this_ptr_conv.inner = untag_ptr(this_ptr);
23009 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23011 this_ptr_conv.is_owned = false;
23012 LDKStr val_conv = str_ref_to_owned_c(val);
23013 UntrustedString_set_a(&this_ptr_conv, val_conv);
23016 uint64_t __attribute__((export_name("TS_UntrustedString_new"))) TS_UntrustedString_new(jstring a_arg) {
23017 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
23018 LDKUntrustedString ret_var = UntrustedString_new(a_arg_conv);
23019 uint64_t ret_ref = 0;
23020 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23021 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23025 static inline uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg) {
23026 LDKUntrustedString ret_var = UntrustedString_clone(arg);
23027 uint64_t ret_ref = 0;
23028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23029 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23032 int64_t __attribute__((export_name("TS_UntrustedString_clone_ptr"))) TS_UntrustedString_clone_ptr(uint64_t arg) {
23033 LDKUntrustedString arg_conv;
23034 arg_conv.inner = untag_ptr(arg);
23035 arg_conv.is_owned = ptr_is_owned(arg);
23036 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23037 arg_conv.is_owned = false;
23038 int64_t ret_conv = UntrustedString_clone_ptr(&arg_conv);
23042 uint64_t __attribute__((export_name("TS_UntrustedString_clone"))) TS_UntrustedString_clone(uint64_t orig) {
23043 LDKUntrustedString orig_conv;
23044 orig_conv.inner = untag_ptr(orig);
23045 orig_conv.is_owned = ptr_is_owned(orig);
23046 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23047 orig_conv.is_owned = false;
23048 LDKUntrustedString ret_var = UntrustedString_clone(&orig_conv);
23049 uint64_t ret_ref = 0;
23050 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23051 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23055 jboolean __attribute__((export_name("TS_UntrustedString_eq"))) TS_UntrustedString_eq(uint64_t a, uint64_t b) {
23056 LDKUntrustedString a_conv;
23057 a_conv.inner = untag_ptr(a);
23058 a_conv.is_owned = ptr_is_owned(a);
23059 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23060 a_conv.is_owned = false;
23061 LDKUntrustedString b_conv;
23062 b_conv.inner = untag_ptr(b);
23063 b_conv.is_owned = ptr_is_owned(b);
23064 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
23065 b_conv.is_owned = false;
23066 jboolean ret_conv = UntrustedString_eq(&a_conv, &b_conv);
23070 int8_tArray __attribute__((export_name("TS_UntrustedString_write"))) TS_UntrustedString_write(uint64_t obj) {
23071 LDKUntrustedString obj_conv;
23072 obj_conv.inner = untag_ptr(obj);
23073 obj_conv.is_owned = ptr_is_owned(obj);
23074 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
23075 obj_conv.is_owned = false;
23076 LDKCVec_u8Z ret_var = UntrustedString_write(&obj_conv);
23077 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23078 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23079 CVec_u8Z_free(ret_var);
23083 uint64_t __attribute__((export_name("TS_UntrustedString_read"))) TS_UntrustedString_read(int8_tArray ser) {
23084 LDKu8slice ser_ref;
23085 ser_ref.datalen = ser->arr_len;
23086 ser_ref.data = ser->elems;
23087 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
23088 *ret_conv = UntrustedString_read(ser_ref);
23090 return tag_ptr(ret_conv, true);
23093 void __attribute__((export_name("TS_PrintableString_free"))) TS_PrintableString_free(uint64_t this_obj) {
23094 LDKPrintableString this_obj_conv;
23095 this_obj_conv.inner = untag_ptr(this_obj);
23096 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23098 PrintableString_free(this_obj_conv);
23101 jstring __attribute__((export_name("TS_PrintableString_get_a"))) TS_PrintableString_get_a(uint64_t this_ptr) {
23102 LDKPrintableString this_ptr_conv;
23103 this_ptr_conv.inner = untag_ptr(this_ptr);
23104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23106 this_ptr_conv.is_owned = false;
23107 LDKStr ret_str = PrintableString_get_a(&this_ptr_conv);
23108 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23113 void __attribute__((export_name("TS_PrintableString_set_a"))) TS_PrintableString_set_a(uint64_t this_ptr, jstring val) {
23114 LDKPrintableString this_ptr_conv;
23115 this_ptr_conv.inner = untag_ptr(this_ptr);
23116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23118 this_ptr_conv.is_owned = false;
23119 LDKStr val_conv = str_ref_to_owned_c(val);
23120 PrintableString_set_a(&this_ptr_conv, val_conv);
23123 uint64_t __attribute__((export_name("TS_PrintableString_new"))) TS_PrintableString_new(jstring a_arg) {
23124 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
23125 LDKPrintableString ret_var = PrintableString_new(a_arg_conv);
23126 uint64_t ret_ref = 0;
23127 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23128 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23132 void __attribute__((export_name("TS_FutureCallback_free"))) TS_FutureCallback_free(uint64_t this_ptr) {
23133 if (!ptr_is_owned(this_ptr)) return;
23134 void* this_ptr_ptr = untag_ptr(this_ptr);
23135 CHECK_ACCESS(this_ptr_ptr);
23136 LDKFutureCallback this_ptr_conv = *(LDKFutureCallback*)(this_ptr_ptr);
23137 FREE(untag_ptr(this_ptr));
23138 FutureCallback_free(this_ptr_conv);
23141 void __attribute__((export_name("TS_Future_free"))) TS_Future_free(uint64_t this_obj) {
23142 LDKFuture this_obj_conv;
23143 this_obj_conv.inner = untag_ptr(this_obj);
23144 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23146 Future_free(this_obj_conv);
23149 static inline uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg) {
23150 LDKFuture ret_var = Future_clone(arg);
23151 uint64_t ret_ref = 0;
23152 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23153 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23156 int64_t __attribute__((export_name("TS_Future_clone_ptr"))) TS_Future_clone_ptr(uint64_t arg) {
23157 LDKFuture arg_conv;
23158 arg_conv.inner = untag_ptr(arg);
23159 arg_conv.is_owned = ptr_is_owned(arg);
23160 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23161 arg_conv.is_owned = false;
23162 int64_t ret_conv = Future_clone_ptr(&arg_conv);
23166 uint64_t __attribute__((export_name("TS_Future_clone"))) TS_Future_clone(uint64_t orig) {
23167 LDKFuture orig_conv;
23168 orig_conv.inner = untag_ptr(orig);
23169 orig_conv.is_owned = ptr_is_owned(orig);
23170 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23171 orig_conv.is_owned = false;
23172 LDKFuture ret_var = Future_clone(&orig_conv);
23173 uint64_t ret_ref = 0;
23174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23175 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23179 void __attribute__((export_name("TS_Future_register_callback_fn"))) TS_Future_register_callback_fn(uint64_t this_arg, uint64_t callback) {
23180 LDKFuture this_arg_conv;
23181 this_arg_conv.inner = untag_ptr(this_arg);
23182 this_arg_conv.is_owned = ptr_is_owned(this_arg);
23183 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23184 this_arg_conv.is_owned = false;
23185 void* callback_ptr = untag_ptr(callback);
23186 CHECK_ACCESS(callback_ptr);
23187 LDKFutureCallback callback_conv = *(LDKFutureCallback*)(callback_ptr);
23188 if (callback_conv.free == LDKFutureCallback_JCalls_free) {
23189 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23190 LDKFutureCallback_JCalls_cloned(&callback_conv);
23192 Future_register_callback_fn(&this_arg_conv, callback_conv);
23195 uint32_t __attribute__((export_name("TS_Level_clone"))) TS_Level_clone(uint64_t orig) {
23196 LDKLevel* orig_conv = (LDKLevel*)untag_ptr(orig);
23197 uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
23201 uint32_t __attribute__((export_name("TS_Level_gossip"))) TS_Level_gossip() {
23202 uint32_t ret_conv = LDKLevel_to_js(Level_gossip());
23206 uint32_t __attribute__((export_name("TS_Level_trace"))) TS_Level_trace() {
23207 uint32_t ret_conv = LDKLevel_to_js(Level_trace());
23211 uint32_t __attribute__((export_name("TS_Level_debug"))) TS_Level_debug() {
23212 uint32_t ret_conv = LDKLevel_to_js(Level_debug());
23216 uint32_t __attribute__((export_name("TS_Level_info"))) TS_Level_info() {
23217 uint32_t ret_conv = LDKLevel_to_js(Level_info());
23221 uint32_t __attribute__((export_name("TS_Level_warn"))) TS_Level_warn() {
23222 uint32_t ret_conv = LDKLevel_to_js(Level_warn());
23226 uint32_t __attribute__((export_name("TS_Level_error"))) TS_Level_error() {
23227 uint32_t ret_conv = LDKLevel_to_js(Level_error());
23231 jboolean __attribute__((export_name("TS_Level_eq"))) TS_Level_eq(uint64_t a, uint64_t b) {
23232 LDKLevel* a_conv = (LDKLevel*)untag_ptr(a);
23233 LDKLevel* b_conv = (LDKLevel*)untag_ptr(b);
23234 jboolean ret_conv = Level_eq(a_conv, b_conv);
23238 int64_t __attribute__((export_name("TS_Level_hash"))) TS_Level_hash(uint64_t o) {
23239 LDKLevel* o_conv = (LDKLevel*)untag_ptr(o);
23240 int64_t ret_conv = Level_hash(o_conv);
23244 uint32_t __attribute__((export_name("TS_Level_max"))) TS_Level_max() {
23245 uint32_t ret_conv = LDKLevel_to_js(Level_max());
23249 void __attribute__((export_name("TS_Record_free"))) TS_Record_free(uint64_t this_obj) {
23250 LDKRecord this_obj_conv;
23251 this_obj_conv.inner = untag_ptr(this_obj);
23252 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23254 Record_free(this_obj_conv);
23257 uint32_t __attribute__((export_name("TS_Record_get_level"))) TS_Record_get_level(uint64_t this_ptr) {
23258 LDKRecord this_ptr_conv;
23259 this_ptr_conv.inner = untag_ptr(this_ptr);
23260 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23262 this_ptr_conv.is_owned = false;
23263 uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
23267 void __attribute__((export_name("TS_Record_set_level"))) TS_Record_set_level(uint64_t this_ptr, uint32_t val) {
23268 LDKRecord this_ptr_conv;
23269 this_ptr_conv.inner = untag_ptr(this_ptr);
23270 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23272 this_ptr_conv.is_owned = false;
23273 LDKLevel val_conv = LDKLevel_from_js(val);
23274 Record_set_level(&this_ptr_conv, val_conv);
23277 jstring __attribute__((export_name("TS_Record_get_args"))) TS_Record_get_args(uint64_t this_ptr) {
23278 LDKRecord this_ptr_conv;
23279 this_ptr_conv.inner = untag_ptr(this_ptr);
23280 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23282 this_ptr_conv.is_owned = false;
23283 LDKStr ret_str = Record_get_args(&this_ptr_conv);
23284 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23289 void __attribute__((export_name("TS_Record_set_args"))) TS_Record_set_args(uint64_t this_ptr, jstring val) {
23290 LDKRecord this_ptr_conv;
23291 this_ptr_conv.inner = untag_ptr(this_ptr);
23292 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23294 this_ptr_conv.is_owned = false;
23295 LDKStr val_conv = str_ref_to_owned_c(val);
23296 Record_set_args(&this_ptr_conv, val_conv);
23299 jstring __attribute__((export_name("TS_Record_get_module_path"))) TS_Record_get_module_path(uint64_t this_ptr) {
23300 LDKRecord this_ptr_conv;
23301 this_ptr_conv.inner = untag_ptr(this_ptr);
23302 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23304 this_ptr_conv.is_owned = false;
23305 LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
23306 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23311 void __attribute__((export_name("TS_Record_set_module_path"))) TS_Record_set_module_path(uint64_t this_ptr, jstring val) {
23312 LDKRecord this_ptr_conv;
23313 this_ptr_conv.inner = untag_ptr(this_ptr);
23314 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23316 this_ptr_conv.is_owned = false;
23317 LDKStr val_conv = str_ref_to_owned_c(val);
23318 Record_set_module_path(&this_ptr_conv, val_conv);
23321 jstring __attribute__((export_name("TS_Record_get_file"))) TS_Record_get_file(uint64_t this_ptr) {
23322 LDKRecord this_ptr_conv;
23323 this_ptr_conv.inner = untag_ptr(this_ptr);
23324 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23326 this_ptr_conv.is_owned = false;
23327 LDKStr ret_str = Record_get_file(&this_ptr_conv);
23328 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23333 void __attribute__((export_name("TS_Record_set_file"))) TS_Record_set_file(uint64_t this_ptr, jstring val) {
23334 LDKRecord this_ptr_conv;
23335 this_ptr_conv.inner = untag_ptr(this_ptr);
23336 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23337 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23338 this_ptr_conv.is_owned = false;
23339 LDKStr val_conv = str_ref_to_owned_c(val);
23340 Record_set_file(&this_ptr_conv, val_conv);
23343 int32_t __attribute__((export_name("TS_Record_get_line"))) TS_Record_get_line(uint64_t this_ptr) {
23344 LDKRecord this_ptr_conv;
23345 this_ptr_conv.inner = untag_ptr(this_ptr);
23346 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23348 this_ptr_conv.is_owned = false;
23349 int32_t ret_conv = Record_get_line(&this_ptr_conv);
23353 void __attribute__((export_name("TS_Record_set_line"))) TS_Record_set_line(uint64_t this_ptr, int32_t val) {
23354 LDKRecord this_ptr_conv;
23355 this_ptr_conv.inner = untag_ptr(this_ptr);
23356 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23357 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23358 this_ptr_conv.is_owned = false;
23359 Record_set_line(&this_ptr_conv, val);
23362 static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
23363 LDKRecord ret_var = Record_clone(arg);
23364 uint64_t ret_ref = 0;
23365 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23366 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23369 int64_t __attribute__((export_name("TS_Record_clone_ptr"))) TS_Record_clone_ptr(uint64_t arg) {
23370 LDKRecord arg_conv;
23371 arg_conv.inner = untag_ptr(arg);
23372 arg_conv.is_owned = ptr_is_owned(arg);
23373 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23374 arg_conv.is_owned = false;
23375 int64_t ret_conv = Record_clone_ptr(&arg_conv);
23379 uint64_t __attribute__((export_name("TS_Record_clone"))) TS_Record_clone(uint64_t orig) {
23380 LDKRecord orig_conv;
23381 orig_conv.inner = untag_ptr(orig);
23382 orig_conv.is_owned = ptr_is_owned(orig);
23383 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23384 orig_conv.is_owned = false;
23385 LDKRecord ret_var = Record_clone(&orig_conv);
23386 uint64_t ret_ref = 0;
23387 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23388 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23392 void __attribute__((export_name("TS_Logger_free"))) TS_Logger_free(uint64_t this_ptr) {
23393 if (!ptr_is_owned(this_ptr)) return;
23394 void* this_ptr_ptr = untag_ptr(this_ptr);
23395 CHECK_ACCESS(this_ptr_ptr);
23396 LDKLogger this_ptr_conv = *(LDKLogger*)(this_ptr_ptr);
23397 FREE(untag_ptr(this_ptr));
23398 Logger_free(this_ptr_conv);
23401 void __attribute__((export_name("TS_ChannelHandshakeConfig_free"))) TS_ChannelHandshakeConfig_free(uint64_t this_obj) {
23402 LDKChannelHandshakeConfig this_obj_conv;
23403 this_obj_conv.inner = untag_ptr(this_obj);
23404 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23406 ChannelHandshakeConfig_free(this_obj_conv);
23409 int32_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_minimum_depth"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint64_t this_ptr) {
23410 LDKChannelHandshakeConfig this_ptr_conv;
23411 this_ptr_conv.inner = untag_ptr(this_ptr);
23412 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23414 this_ptr_conv.is_owned = false;
23415 int32_t ret_conv = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
23419 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_minimum_depth"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint64_t this_ptr, int32_t val) {
23420 LDKChannelHandshakeConfig this_ptr_conv;
23421 this_ptr_conv.inner = untag_ptr(this_ptr);
23422 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23423 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23424 this_ptr_conv.is_owned = false;
23425 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
23428 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_to_self_delay"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint64_t this_ptr) {
23429 LDKChannelHandshakeConfig this_ptr_conv;
23430 this_ptr_conv.inner = untag_ptr(this_ptr);
23431 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23433 this_ptr_conv.is_owned = false;
23434 int16_t ret_conv = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
23438 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) {
23439 LDKChannelHandshakeConfig this_ptr_conv;
23440 this_ptr_conv.inner = untag_ptr(this_ptr);
23441 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23442 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23443 this_ptr_conv.is_owned = false;
23444 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
23447 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint64_t this_ptr) {
23448 LDKChannelHandshakeConfig this_ptr_conv;
23449 this_ptr_conv.inner = untag_ptr(this_ptr);
23450 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23452 this_ptr_conv.is_owned = false;
23453 int64_t ret_conv = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
23457 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) {
23458 LDKChannelHandshakeConfig this_ptr_conv;
23459 this_ptr_conv.inner = untag_ptr(this_ptr);
23460 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23461 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23462 this_ptr_conv.is_owned = false;
23463 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
23466 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) {
23467 LDKChannelHandshakeConfig this_ptr_conv;
23468 this_ptr_conv.inner = untag_ptr(this_ptr);
23469 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23471 this_ptr_conv.is_owned = false;
23472 int8_t ret_conv = ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv);
23476 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) {
23477 LDKChannelHandshakeConfig this_ptr_conv;
23478 this_ptr_conv.inner = untag_ptr(this_ptr);
23479 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23481 this_ptr_conv.is_owned = false;
23482 ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv, val);
23485 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(uint64_t this_ptr) {
23486 LDKChannelHandshakeConfig this_ptr_conv;
23487 this_ptr_conv.inner = untag_ptr(this_ptr);
23488 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23490 this_ptr_conv.is_owned = false;
23491 jboolean ret_conv = ChannelHandshakeConfig_get_negotiate_scid_privacy(&this_ptr_conv);
23495 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(uint64_t this_ptr, jboolean val) {
23496 LDKChannelHandshakeConfig this_ptr_conv;
23497 this_ptr_conv.inner = untag_ptr(this_ptr);
23498 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23499 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23500 this_ptr_conv.is_owned = false;
23501 ChannelHandshakeConfig_set_negotiate_scid_privacy(&this_ptr_conv, val);
23504 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_announced_channel"))) TS_ChannelHandshakeConfig_get_announced_channel(uint64_t this_ptr) {
23505 LDKChannelHandshakeConfig this_ptr_conv;
23506 this_ptr_conv.inner = untag_ptr(this_ptr);
23507 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23508 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23509 this_ptr_conv.is_owned = false;
23510 jboolean ret_conv = ChannelHandshakeConfig_get_announced_channel(&this_ptr_conv);
23514 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_announced_channel"))) TS_ChannelHandshakeConfig_set_announced_channel(uint64_t this_ptr, jboolean val) {
23515 LDKChannelHandshakeConfig this_ptr_conv;
23516 this_ptr_conv.inner = untag_ptr(this_ptr);
23517 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23518 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23519 this_ptr_conv.is_owned = false;
23520 ChannelHandshakeConfig_set_announced_channel(&this_ptr_conv, val);
23523 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(uint64_t this_ptr) {
23524 LDKChannelHandshakeConfig this_ptr_conv;
23525 this_ptr_conv.inner = untag_ptr(this_ptr);
23526 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23528 this_ptr_conv.is_owned = false;
23529 jboolean ret_conv = ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
23533 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(uint64_t this_ptr, jboolean val) {
23534 LDKChannelHandshakeConfig this_ptr_conv;
23535 this_ptr_conv.inner = untag_ptr(this_ptr);
23536 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23537 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23538 this_ptr_conv.is_owned = false;
23539 ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
23542 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) {
23543 LDKChannelHandshakeConfig this_ptr_conv;
23544 this_ptr_conv.inner = untag_ptr(this_ptr);
23545 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23547 this_ptr_conv.is_owned = false;
23548 int32_t ret_conv = ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(&this_ptr_conv);
23552 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) {
23553 LDKChannelHandshakeConfig this_ptr_conv;
23554 this_ptr_conv.inner = untag_ptr(this_ptr);
23555 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23557 this_ptr_conv.is_owned = false;
23558 ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(&this_ptr_conv, val);
23561 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs"))) TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(uint64_t this_ptr) {
23562 LDKChannelHandshakeConfig this_ptr_conv;
23563 this_ptr_conv.inner = untag_ptr(this_ptr);
23564 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23566 this_ptr_conv.is_owned = false;
23567 int16_t ret_conv = ChannelHandshakeConfig_get_our_max_accepted_htlcs(&this_ptr_conv);
23571 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) {
23572 LDKChannelHandshakeConfig this_ptr_conv;
23573 this_ptr_conv.inner = untag_ptr(this_ptr);
23574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23576 this_ptr_conv.is_owned = false;
23577 ChannelHandshakeConfig_set_our_max_accepted_htlcs(&this_ptr_conv, val);
23580 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) {
23581 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);
23582 uint64_t ret_ref = 0;
23583 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23584 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23588 static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
23589 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
23590 uint64_t ret_ref = 0;
23591 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23592 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23595 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone_ptr"))) TS_ChannelHandshakeConfig_clone_ptr(uint64_t arg) {
23596 LDKChannelHandshakeConfig arg_conv;
23597 arg_conv.inner = untag_ptr(arg);
23598 arg_conv.is_owned = ptr_is_owned(arg);
23599 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23600 arg_conv.is_owned = false;
23601 int64_t ret_conv = ChannelHandshakeConfig_clone_ptr(&arg_conv);
23605 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone"))) TS_ChannelHandshakeConfig_clone(uint64_t orig) {
23606 LDKChannelHandshakeConfig orig_conv;
23607 orig_conv.inner = untag_ptr(orig);
23608 orig_conv.is_owned = ptr_is_owned(orig);
23609 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23610 orig_conv.is_owned = false;
23611 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
23612 uint64_t ret_ref = 0;
23613 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23614 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23618 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_default"))) TS_ChannelHandshakeConfig_default() {
23619 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
23620 uint64_t ret_ref = 0;
23621 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23622 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23626 void __attribute__((export_name("TS_ChannelHandshakeLimits_free"))) TS_ChannelHandshakeLimits_free(uint64_t this_obj) {
23627 LDKChannelHandshakeLimits this_obj_conv;
23628 this_obj_conv.inner = untag_ptr(this_obj);
23629 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23631 ChannelHandshakeLimits_free(this_obj_conv);
23634 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_funding_satoshis"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint64_t this_ptr) {
23635 LDKChannelHandshakeLimits this_ptr_conv;
23636 this_ptr_conv.inner = untag_ptr(this_ptr);
23637 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23639 this_ptr_conv.is_owned = false;
23640 int64_t ret_conv = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
23644 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_funding_satoshis"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint64_t this_ptr, int64_t val) {
23645 LDKChannelHandshakeLimits this_ptr_conv;
23646 this_ptr_conv.inner = untag_ptr(this_ptr);
23647 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23649 this_ptr_conv.is_owned = false;
23650 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
23653 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_funding_satoshis"))) TS_ChannelHandshakeLimits_get_max_funding_satoshis(uint64_t this_ptr) {
23654 LDKChannelHandshakeLimits this_ptr_conv;
23655 this_ptr_conv.inner = untag_ptr(this_ptr);
23656 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23658 this_ptr_conv.is_owned = false;
23659 int64_t ret_conv = ChannelHandshakeLimits_get_max_funding_satoshis(&this_ptr_conv);
23663 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_funding_satoshis"))) TS_ChannelHandshakeLimits_set_max_funding_satoshis(uint64_t this_ptr, int64_t val) {
23664 LDKChannelHandshakeLimits this_ptr_conv;
23665 this_ptr_conv.inner = untag_ptr(this_ptr);
23666 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23668 this_ptr_conv.is_owned = false;
23669 ChannelHandshakeLimits_set_max_funding_satoshis(&this_ptr_conv, val);
23672 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint64_t this_ptr) {
23673 LDKChannelHandshakeLimits this_ptr_conv;
23674 this_ptr_conv.inner = untag_ptr(this_ptr);
23675 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23677 this_ptr_conv.is_owned = false;
23678 int64_t ret_conv = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
23682 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) {
23683 LDKChannelHandshakeLimits this_ptr_conv;
23684 this_ptr_conv.inner = untag_ptr(this_ptr);
23685 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23686 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23687 this_ptr_conv.is_owned = false;
23688 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
23691 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) {
23692 LDKChannelHandshakeLimits this_ptr_conv;
23693 this_ptr_conv.inner = untag_ptr(this_ptr);
23694 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23695 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23696 this_ptr_conv.is_owned = false;
23697 int64_t ret_conv = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
23701 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) {
23702 LDKChannelHandshakeLimits this_ptr_conv;
23703 this_ptr_conv.inner = untag_ptr(this_ptr);
23704 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23706 this_ptr_conv.is_owned = false;
23707 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
23710 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint64_t this_ptr) {
23711 LDKChannelHandshakeLimits this_ptr_conv;
23712 this_ptr_conv.inner = untag_ptr(this_ptr);
23713 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23715 this_ptr_conv.is_owned = false;
23716 int64_t ret_conv = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
23720 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) {
23721 LDKChannelHandshakeLimits this_ptr_conv;
23722 this_ptr_conv.inner = untag_ptr(this_ptr);
23723 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23724 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23725 this_ptr_conv.is_owned = false;
23726 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
23729 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint64_t this_ptr) {
23730 LDKChannelHandshakeLimits this_ptr_conv;
23731 this_ptr_conv.inner = untag_ptr(this_ptr);
23732 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23734 this_ptr_conv.is_owned = false;
23735 int16_t ret_conv = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
23739 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) {
23740 LDKChannelHandshakeLimits this_ptr_conv;
23741 this_ptr_conv.inner = untag_ptr(this_ptr);
23742 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23744 this_ptr_conv.is_owned = false;
23745 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
23748 int32_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_minimum_depth"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint64_t this_ptr) {
23749 LDKChannelHandshakeLimits this_ptr_conv;
23750 this_ptr_conv.inner = untag_ptr(this_ptr);
23751 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23753 this_ptr_conv.is_owned = false;
23754 int32_t ret_conv = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
23758 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_minimum_depth"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint64_t this_ptr, int32_t val) {
23759 LDKChannelHandshakeLimits this_ptr_conv;
23760 this_ptr_conv.inner = untag_ptr(this_ptr);
23761 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23763 this_ptr_conv.is_owned = false;
23764 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
23767 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(uint64_t this_ptr) {
23768 LDKChannelHandshakeLimits this_ptr_conv;
23769 this_ptr_conv.inner = untag_ptr(this_ptr);
23770 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23772 this_ptr_conv.is_owned = false;
23773 jboolean ret_conv = ChannelHandshakeLimits_get_trust_own_funding_0conf(&this_ptr_conv);
23777 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(uint64_t this_ptr, jboolean val) {
23778 LDKChannelHandshakeLimits this_ptr_conv;
23779 this_ptr_conv.inner = untag_ptr(this_ptr);
23780 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23781 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23782 this_ptr_conv.is_owned = false;
23783 ChannelHandshakeLimits_set_trust_own_funding_0conf(&this_ptr_conv, val);
23786 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint64_t this_ptr) {
23787 LDKChannelHandshakeLimits this_ptr_conv;
23788 this_ptr_conv.inner = untag_ptr(this_ptr);
23789 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23790 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23791 this_ptr_conv.is_owned = false;
23792 jboolean ret_conv = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
23796 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint64_t this_ptr, jboolean val) {
23797 LDKChannelHandshakeLimits this_ptr_conv;
23798 this_ptr_conv.inner = untag_ptr(this_ptr);
23799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23801 this_ptr_conv.is_owned = false;
23802 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
23805 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_their_to_self_delay"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint64_t this_ptr) {
23806 LDKChannelHandshakeLimits this_ptr_conv;
23807 this_ptr_conv.inner = untag_ptr(this_ptr);
23808 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23810 this_ptr_conv.is_owned = false;
23811 int16_t ret_conv = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
23815 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) {
23816 LDKChannelHandshakeLimits this_ptr_conv;
23817 this_ptr_conv.inner = untag_ptr(this_ptr);
23818 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23820 this_ptr_conv.is_owned = false;
23821 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
23824 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) {
23825 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);
23826 uint64_t ret_ref = 0;
23827 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23828 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23832 static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
23833 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
23834 uint64_t ret_ref = 0;
23835 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23836 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23839 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone_ptr"))) TS_ChannelHandshakeLimits_clone_ptr(uint64_t arg) {
23840 LDKChannelHandshakeLimits arg_conv;
23841 arg_conv.inner = untag_ptr(arg);
23842 arg_conv.is_owned = ptr_is_owned(arg);
23843 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23844 arg_conv.is_owned = false;
23845 int64_t ret_conv = ChannelHandshakeLimits_clone_ptr(&arg_conv);
23849 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone"))) TS_ChannelHandshakeLimits_clone(uint64_t orig) {
23850 LDKChannelHandshakeLimits orig_conv;
23851 orig_conv.inner = untag_ptr(orig);
23852 orig_conv.is_owned = ptr_is_owned(orig);
23853 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23854 orig_conv.is_owned = false;
23855 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
23856 uint64_t ret_ref = 0;
23857 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23858 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23862 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_default"))) TS_ChannelHandshakeLimits_default() {
23863 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
23864 uint64_t ret_ref = 0;
23865 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23866 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23870 void __attribute__((export_name("TS_ChannelConfig_free"))) TS_ChannelConfig_free(uint64_t this_obj) {
23871 LDKChannelConfig this_obj_conv;
23872 this_obj_conv.inner = untag_ptr(this_obj);
23873 this_obj_conv.is_owned = ptr_is_owned(this_obj);
23874 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23875 ChannelConfig_free(this_obj_conv);
23878 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_get_forwarding_fee_proportional_millionths(uint64_t this_ptr) {
23879 LDKChannelConfig this_ptr_conv;
23880 this_ptr_conv.inner = untag_ptr(this_ptr);
23881 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23883 this_ptr_conv.is_owned = false;
23884 int32_t ret_conv = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
23888 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) {
23889 LDKChannelConfig this_ptr_conv;
23890 this_ptr_conv.inner = untag_ptr(this_ptr);
23891 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23892 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23893 this_ptr_conv.is_owned = false;
23894 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
23897 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_base_msat"))) TS_ChannelConfig_get_forwarding_fee_base_msat(uint64_t this_ptr) {
23898 LDKChannelConfig this_ptr_conv;
23899 this_ptr_conv.inner = untag_ptr(this_ptr);
23900 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23901 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23902 this_ptr_conv.is_owned = false;
23903 int32_t ret_conv = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
23907 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) {
23908 LDKChannelConfig this_ptr_conv;
23909 this_ptr_conv.inner = untag_ptr(this_ptr);
23910 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23911 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23912 this_ptr_conv.is_owned = false;
23913 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
23916 int16_t __attribute__((export_name("TS_ChannelConfig_get_cltv_expiry_delta"))) TS_ChannelConfig_get_cltv_expiry_delta(uint64_t this_ptr) {
23917 LDKChannelConfig this_ptr_conv;
23918 this_ptr_conv.inner = untag_ptr(this_ptr);
23919 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23921 this_ptr_conv.is_owned = false;
23922 int16_t ret_conv = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
23926 void __attribute__((export_name("TS_ChannelConfig_set_cltv_expiry_delta"))) TS_ChannelConfig_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
23927 LDKChannelConfig this_ptr_conv;
23928 this_ptr_conv.inner = untag_ptr(this_ptr);
23929 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23930 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23931 this_ptr_conv.is_owned = false;
23932 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
23935 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) {
23936 LDKChannelConfig this_ptr_conv;
23937 this_ptr_conv.inner = untag_ptr(this_ptr);
23938 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23939 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23940 this_ptr_conv.is_owned = false;
23941 int64_t ret_conv = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
23945 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) {
23946 LDKChannelConfig this_ptr_conv;
23947 this_ptr_conv.inner = untag_ptr(this_ptr);
23948 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23950 this_ptr_conv.is_owned = false;
23951 ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
23954 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) {
23955 LDKChannelConfig this_ptr_conv;
23956 this_ptr_conv.inner = untag_ptr(this_ptr);
23957 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23959 this_ptr_conv.is_owned = false;
23960 int64_t ret_conv = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
23964 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) {
23965 LDKChannelConfig this_ptr_conv;
23966 this_ptr_conv.inner = untag_ptr(this_ptr);
23967 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
23968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23969 this_ptr_conv.is_owned = false;
23970 ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
23973 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) {
23974 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);
23975 uint64_t ret_ref = 0;
23976 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23977 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23981 static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
23982 LDKChannelConfig ret_var = ChannelConfig_clone(arg);
23983 uint64_t ret_ref = 0;
23984 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23985 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
23988 int64_t __attribute__((export_name("TS_ChannelConfig_clone_ptr"))) TS_ChannelConfig_clone_ptr(uint64_t arg) {
23989 LDKChannelConfig arg_conv;
23990 arg_conv.inner = untag_ptr(arg);
23991 arg_conv.is_owned = ptr_is_owned(arg);
23992 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23993 arg_conv.is_owned = false;
23994 int64_t ret_conv = ChannelConfig_clone_ptr(&arg_conv);
23998 uint64_t __attribute__((export_name("TS_ChannelConfig_clone"))) TS_ChannelConfig_clone(uint64_t orig) {
23999 LDKChannelConfig orig_conv;
24000 orig_conv.inner = untag_ptr(orig);
24001 orig_conv.is_owned = ptr_is_owned(orig);
24002 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24003 orig_conv.is_owned = false;
24004 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
24005 uint64_t ret_ref = 0;
24006 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24007 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24011 jboolean __attribute__((export_name("TS_ChannelConfig_eq"))) TS_ChannelConfig_eq(uint64_t a, uint64_t b) {
24012 LDKChannelConfig a_conv;
24013 a_conv.inner = untag_ptr(a);
24014 a_conv.is_owned = ptr_is_owned(a);
24015 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24016 a_conv.is_owned = false;
24017 LDKChannelConfig b_conv;
24018 b_conv.inner = untag_ptr(b);
24019 b_conv.is_owned = ptr_is_owned(b);
24020 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24021 b_conv.is_owned = false;
24022 jboolean ret_conv = ChannelConfig_eq(&a_conv, &b_conv);
24026 uint64_t __attribute__((export_name("TS_ChannelConfig_default"))) TS_ChannelConfig_default() {
24027 LDKChannelConfig ret_var = ChannelConfig_default();
24028 uint64_t ret_ref = 0;
24029 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24030 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24034 int8_tArray __attribute__((export_name("TS_ChannelConfig_write"))) TS_ChannelConfig_write(uint64_t obj) {
24035 LDKChannelConfig obj_conv;
24036 obj_conv.inner = untag_ptr(obj);
24037 obj_conv.is_owned = ptr_is_owned(obj);
24038 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
24039 obj_conv.is_owned = false;
24040 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
24041 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24042 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24043 CVec_u8Z_free(ret_var);
24047 uint64_t __attribute__((export_name("TS_ChannelConfig_read"))) TS_ChannelConfig_read(int8_tArray ser) {
24048 LDKu8slice ser_ref;
24049 ser_ref.datalen = ser->arr_len;
24050 ser_ref.data = ser->elems;
24051 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
24052 *ret_conv = ChannelConfig_read(ser_ref);
24054 return tag_ptr(ret_conv, true);
24057 void __attribute__((export_name("TS_UserConfig_free"))) TS_UserConfig_free(uint64_t this_obj) {
24058 LDKUserConfig this_obj_conv;
24059 this_obj_conv.inner = untag_ptr(this_obj);
24060 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24061 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24062 UserConfig_free(this_obj_conv);
24065 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_config"))) TS_UserConfig_get_channel_handshake_config(uint64_t this_ptr) {
24066 LDKUserConfig this_ptr_conv;
24067 this_ptr_conv.inner = untag_ptr(this_ptr);
24068 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24069 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24070 this_ptr_conv.is_owned = false;
24071 LDKChannelHandshakeConfig ret_var = UserConfig_get_channel_handshake_config(&this_ptr_conv);
24072 uint64_t ret_ref = 0;
24073 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24074 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24078 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_config"))) TS_UserConfig_set_channel_handshake_config(uint64_t this_ptr, uint64_t val) {
24079 LDKUserConfig this_ptr_conv;
24080 this_ptr_conv.inner = untag_ptr(this_ptr);
24081 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24083 this_ptr_conv.is_owned = false;
24084 LDKChannelHandshakeConfig val_conv;
24085 val_conv.inner = untag_ptr(val);
24086 val_conv.is_owned = ptr_is_owned(val);
24087 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24088 val_conv = ChannelHandshakeConfig_clone(&val_conv);
24089 UserConfig_set_channel_handshake_config(&this_ptr_conv, val_conv);
24092 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_limits"))) TS_UserConfig_get_channel_handshake_limits(uint64_t this_ptr) {
24093 LDKUserConfig this_ptr_conv;
24094 this_ptr_conv.inner = untag_ptr(this_ptr);
24095 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24096 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24097 this_ptr_conv.is_owned = false;
24098 LDKChannelHandshakeLimits ret_var = UserConfig_get_channel_handshake_limits(&this_ptr_conv);
24099 uint64_t ret_ref = 0;
24100 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24101 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24105 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_limits"))) TS_UserConfig_set_channel_handshake_limits(uint64_t this_ptr, uint64_t val) {
24106 LDKUserConfig this_ptr_conv;
24107 this_ptr_conv.inner = untag_ptr(this_ptr);
24108 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24110 this_ptr_conv.is_owned = false;
24111 LDKChannelHandshakeLimits val_conv;
24112 val_conv.inner = untag_ptr(val);
24113 val_conv.is_owned = ptr_is_owned(val);
24114 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24115 val_conv = ChannelHandshakeLimits_clone(&val_conv);
24116 UserConfig_set_channel_handshake_limits(&this_ptr_conv, val_conv);
24119 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_config"))) TS_UserConfig_get_channel_config(uint64_t this_ptr) {
24120 LDKUserConfig this_ptr_conv;
24121 this_ptr_conv.inner = untag_ptr(this_ptr);
24122 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24123 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24124 this_ptr_conv.is_owned = false;
24125 LDKChannelConfig ret_var = UserConfig_get_channel_config(&this_ptr_conv);
24126 uint64_t ret_ref = 0;
24127 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24128 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24132 void __attribute__((export_name("TS_UserConfig_set_channel_config"))) TS_UserConfig_set_channel_config(uint64_t this_ptr, uint64_t val) {
24133 LDKUserConfig this_ptr_conv;
24134 this_ptr_conv.inner = untag_ptr(this_ptr);
24135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24137 this_ptr_conv.is_owned = false;
24138 LDKChannelConfig val_conv;
24139 val_conv.inner = untag_ptr(val);
24140 val_conv.is_owned = ptr_is_owned(val);
24141 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24142 val_conv = ChannelConfig_clone(&val_conv);
24143 UserConfig_set_channel_config(&this_ptr_conv, val_conv);
24146 jboolean __attribute__((export_name("TS_UserConfig_get_accept_forwards_to_priv_channels"))) TS_UserConfig_get_accept_forwards_to_priv_channels(uint64_t this_ptr) {
24147 LDKUserConfig this_ptr_conv;
24148 this_ptr_conv.inner = untag_ptr(this_ptr);
24149 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24151 this_ptr_conv.is_owned = false;
24152 jboolean ret_conv = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
24156 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) {
24157 LDKUserConfig this_ptr_conv;
24158 this_ptr_conv.inner = untag_ptr(this_ptr);
24159 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24160 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24161 this_ptr_conv.is_owned = false;
24162 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
24165 jboolean __attribute__((export_name("TS_UserConfig_get_accept_inbound_channels"))) TS_UserConfig_get_accept_inbound_channels(uint64_t this_ptr) {
24166 LDKUserConfig this_ptr_conv;
24167 this_ptr_conv.inner = untag_ptr(this_ptr);
24168 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24170 this_ptr_conv.is_owned = false;
24171 jboolean ret_conv = UserConfig_get_accept_inbound_channels(&this_ptr_conv);
24175 void __attribute__((export_name("TS_UserConfig_set_accept_inbound_channels"))) TS_UserConfig_set_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
24176 LDKUserConfig this_ptr_conv;
24177 this_ptr_conv.inner = untag_ptr(this_ptr);
24178 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24179 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24180 this_ptr_conv.is_owned = false;
24181 UserConfig_set_accept_inbound_channels(&this_ptr_conv, val);
24184 jboolean __attribute__((export_name("TS_UserConfig_get_manually_accept_inbound_channels"))) TS_UserConfig_get_manually_accept_inbound_channels(uint64_t this_ptr) {
24185 LDKUserConfig this_ptr_conv;
24186 this_ptr_conv.inner = untag_ptr(this_ptr);
24187 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24189 this_ptr_conv.is_owned = false;
24190 jboolean ret_conv = UserConfig_get_manually_accept_inbound_channels(&this_ptr_conv);
24194 void __attribute__((export_name("TS_UserConfig_set_manually_accept_inbound_channels"))) TS_UserConfig_set_manually_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
24195 LDKUserConfig this_ptr_conv;
24196 this_ptr_conv.inner = untag_ptr(this_ptr);
24197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24199 this_ptr_conv.is_owned = false;
24200 UserConfig_set_manually_accept_inbound_channels(&this_ptr_conv, val);
24203 jboolean __attribute__((export_name("TS_UserConfig_get_accept_intercept_htlcs"))) TS_UserConfig_get_accept_intercept_htlcs(uint64_t this_ptr) {
24204 LDKUserConfig this_ptr_conv;
24205 this_ptr_conv.inner = untag_ptr(this_ptr);
24206 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24208 this_ptr_conv.is_owned = false;
24209 jboolean ret_conv = UserConfig_get_accept_intercept_htlcs(&this_ptr_conv);
24213 void __attribute__((export_name("TS_UserConfig_set_accept_intercept_htlcs"))) TS_UserConfig_set_accept_intercept_htlcs(uint64_t this_ptr, jboolean val) {
24214 LDKUserConfig this_ptr_conv;
24215 this_ptr_conv.inner = untag_ptr(this_ptr);
24216 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24218 this_ptr_conv.is_owned = false;
24219 UserConfig_set_accept_intercept_htlcs(&this_ptr_conv, val);
24222 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) {
24223 LDKChannelHandshakeConfig channel_handshake_config_arg_conv;
24224 channel_handshake_config_arg_conv.inner = untag_ptr(channel_handshake_config_arg);
24225 channel_handshake_config_arg_conv.is_owned = ptr_is_owned(channel_handshake_config_arg);
24226 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_config_arg_conv);
24227 channel_handshake_config_arg_conv = ChannelHandshakeConfig_clone(&channel_handshake_config_arg_conv);
24228 LDKChannelHandshakeLimits channel_handshake_limits_arg_conv;
24229 channel_handshake_limits_arg_conv.inner = untag_ptr(channel_handshake_limits_arg);
24230 channel_handshake_limits_arg_conv.is_owned = ptr_is_owned(channel_handshake_limits_arg);
24231 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_limits_arg_conv);
24232 channel_handshake_limits_arg_conv = ChannelHandshakeLimits_clone(&channel_handshake_limits_arg_conv);
24233 LDKChannelConfig channel_config_arg_conv;
24234 channel_config_arg_conv.inner = untag_ptr(channel_config_arg);
24235 channel_config_arg_conv.is_owned = ptr_is_owned(channel_config_arg);
24236 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_config_arg_conv);
24237 channel_config_arg_conv = ChannelConfig_clone(&channel_config_arg_conv);
24238 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);
24239 uint64_t ret_ref = 0;
24240 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24241 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24245 static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
24246 LDKUserConfig ret_var = UserConfig_clone(arg);
24247 uint64_t ret_ref = 0;
24248 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24249 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24252 int64_t __attribute__((export_name("TS_UserConfig_clone_ptr"))) TS_UserConfig_clone_ptr(uint64_t arg) {
24253 LDKUserConfig arg_conv;
24254 arg_conv.inner = untag_ptr(arg);
24255 arg_conv.is_owned = ptr_is_owned(arg);
24256 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24257 arg_conv.is_owned = false;
24258 int64_t ret_conv = UserConfig_clone_ptr(&arg_conv);
24262 uint64_t __attribute__((export_name("TS_UserConfig_clone"))) TS_UserConfig_clone(uint64_t orig) {
24263 LDKUserConfig orig_conv;
24264 orig_conv.inner = untag_ptr(orig);
24265 orig_conv.is_owned = ptr_is_owned(orig);
24266 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24267 orig_conv.is_owned = false;
24268 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
24269 uint64_t ret_ref = 0;
24270 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24271 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24275 uint64_t __attribute__((export_name("TS_UserConfig_default"))) TS_UserConfig_default() {
24276 LDKUserConfig ret_var = UserConfig_default();
24277 uint64_t ret_ref = 0;
24278 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24279 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24283 void __attribute__((export_name("TS_BestBlock_free"))) TS_BestBlock_free(uint64_t this_obj) {
24284 LDKBestBlock this_obj_conv;
24285 this_obj_conv.inner = untag_ptr(this_obj);
24286 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24288 BestBlock_free(this_obj_conv);
24291 static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
24292 LDKBestBlock ret_var = BestBlock_clone(arg);
24293 uint64_t ret_ref = 0;
24294 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24295 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24298 int64_t __attribute__((export_name("TS_BestBlock_clone_ptr"))) TS_BestBlock_clone_ptr(uint64_t arg) {
24299 LDKBestBlock arg_conv;
24300 arg_conv.inner = untag_ptr(arg);
24301 arg_conv.is_owned = ptr_is_owned(arg);
24302 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24303 arg_conv.is_owned = false;
24304 int64_t ret_conv = BestBlock_clone_ptr(&arg_conv);
24308 uint64_t __attribute__((export_name("TS_BestBlock_clone"))) TS_BestBlock_clone(uint64_t orig) {
24309 LDKBestBlock orig_conv;
24310 orig_conv.inner = untag_ptr(orig);
24311 orig_conv.is_owned = ptr_is_owned(orig);
24312 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24313 orig_conv.is_owned = false;
24314 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
24315 uint64_t ret_ref = 0;
24316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24321 jboolean __attribute__((export_name("TS_BestBlock_eq"))) TS_BestBlock_eq(uint64_t a, uint64_t b) {
24322 LDKBestBlock a_conv;
24323 a_conv.inner = untag_ptr(a);
24324 a_conv.is_owned = ptr_is_owned(a);
24325 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24326 a_conv.is_owned = false;
24327 LDKBestBlock b_conv;
24328 b_conv.inner = untag_ptr(b);
24329 b_conv.is_owned = ptr_is_owned(b);
24330 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24331 b_conv.is_owned = false;
24332 jboolean ret_conv = BestBlock_eq(&a_conv, &b_conv);
24336 uint64_t __attribute__((export_name("TS_BestBlock_from_network"))) TS_BestBlock_from_network(uint32_t network) {
24337 LDKNetwork network_conv = LDKNetwork_from_js(network);
24338 LDKBestBlock ret_var = BestBlock_from_network(network_conv);
24339 uint64_t ret_ref = 0;
24340 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24341 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24345 uint64_t __attribute__((export_name("TS_BestBlock_new"))) TS_BestBlock_new(int8_tArray block_hash, int32_t height) {
24346 LDKThirtyTwoBytes block_hash_ref;
24347 CHECK(block_hash->arr_len == 32);
24348 memcpy(block_hash_ref.data, block_hash->elems, 32); FREE(block_hash);
24349 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
24350 uint64_t ret_ref = 0;
24351 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24352 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24356 int8_tArray __attribute__((export_name("TS_BestBlock_block_hash"))) TS_BestBlock_block_hash(uint64_t this_arg) {
24357 LDKBestBlock this_arg_conv;
24358 this_arg_conv.inner = untag_ptr(this_arg);
24359 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24361 this_arg_conv.is_owned = false;
24362 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24363 memcpy(ret_arr->elems, BestBlock_block_hash(&this_arg_conv).data, 32);
24367 int32_t __attribute__((export_name("TS_BestBlock_height"))) TS_BestBlock_height(uint64_t this_arg) {
24368 LDKBestBlock this_arg_conv;
24369 this_arg_conv.inner = untag_ptr(this_arg);
24370 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24372 this_arg_conv.is_owned = false;
24373 int32_t ret_conv = BestBlock_height(&this_arg_conv);
24377 void __attribute__((export_name("TS_Listen_free"))) TS_Listen_free(uint64_t this_ptr) {
24378 if (!ptr_is_owned(this_ptr)) return;
24379 void* this_ptr_ptr = untag_ptr(this_ptr);
24380 CHECK_ACCESS(this_ptr_ptr);
24381 LDKListen this_ptr_conv = *(LDKListen*)(this_ptr_ptr);
24382 FREE(untag_ptr(this_ptr));
24383 Listen_free(this_ptr_conv);
24386 void __attribute__((export_name("TS_Confirm_free"))) TS_Confirm_free(uint64_t this_ptr) {
24387 if (!ptr_is_owned(this_ptr)) return;
24388 void* this_ptr_ptr = untag_ptr(this_ptr);
24389 CHECK_ACCESS(this_ptr_ptr);
24390 LDKConfirm this_ptr_conv = *(LDKConfirm*)(this_ptr_ptr);
24391 FREE(untag_ptr(this_ptr));
24392 Confirm_free(this_ptr_conv);
24395 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_clone"))) TS_ChannelMonitorUpdateStatus_clone(uint64_t orig) {
24396 LDKChannelMonitorUpdateStatus* orig_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(orig);
24397 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_clone(orig_conv));
24401 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_completed"))) TS_ChannelMonitorUpdateStatus_completed() {
24402 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_completed());
24406 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_in_progress"))) TS_ChannelMonitorUpdateStatus_in_progress() {
24407 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_in_progress());
24411 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_permanent_failure"))) TS_ChannelMonitorUpdateStatus_permanent_failure() {
24412 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_permanent_failure());
24416 jboolean __attribute__((export_name("TS_ChannelMonitorUpdateStatus_eq"))) TS_ChannelMonitorUpdateStatus_eq(uint64_t a, uint64_t b) {
24417 LDKChannelMonitorUpdateStatus* a_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(a);
24418 LDKChannelMonitorUpdateStatus* b_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(b);
24419 jboolean ret_conv = ChannelMonitorUpdateStatus_eq(a_conv, b_conv);
24423 void __attribute__((export_name("TS_Watch_free"))) TS_Watch_free(uint64_t this_ptr) {
24424 if (!ptr_is_owned(this_ptr)) return;
24425 void* this_ptr_ptr = untag_ptr(this_ptr);
24426 CHECK_ACCESS(this_ptr_ptr);
24427 LDKWatch this_ptr_conv = *(LDKWatch*)(this_ptr_ptr);
24428 FREE(untag_ptr(this_ptr));
24429 Watch_free(this_ptr_conv);
24432 void __attribute__((export_name("TS_Filter_free"))) TS_Filter_free(uint64_t this_ptr) {
24433 if (!ptr_is_owned(this_ptr)) return;
24434 void* this_ptr_ptr = untag_ptr(this_ptr);
24435 CHECK_ACCESS(this_ptr_ptr);
24436 LDKFilter this_ptr_conv = *(LDKFilter*)(this_ptr_ptr);
24437 FREE(untag_ptr(this_ptr));
24438 Filter_free(this_ptr_conv);
24441 void __attribute__((export_name("TS_WatchedOutput_free"))) TS_WatchedOutput_free(uint64_t this_obj) {
24442 LDKWatchedOutput this_obj_conv;
24443 this_obj_conv.inner = untag_ptr(this_obj);
24444 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24446 WatchedOutput_free(this_obj_conv);
24449 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_block_hash"))) TS_WatchedOutput_get_block_hash(uint64_t this_ptr) {
24450 LDKWatchedOutput this_ptr_conv;
24451 this_ptr_conv.inner = untag_ptr(this_ptr);
24452 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24453 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24454 this_ptr_conv.is_owned = false;
24455 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24456 memcpy(ret_arr->elems, WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
24460 void __attribute__((export_name("TS_WatchedOutput_set_block_hash"))) TS_WatchedOutput_set_block_hash(uint64_t this_ptr, int8_tArray val) {
24461 LDKWatchedOutput this_ptr_conv;
24462 this_ptr_conv.inner = untag_ptr(this_ptr);
24463 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24464 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24465 this_ptr_conv.is_owned = false;
24466 LDKThirtyTwoBytes val_ref;
24467 CHECK(val->arr_len == 32);
24468 memcpy(val_ref.data, val->elems, 32); FREE(val);
24469 WatchedOutput_set_block_hash(&this_ptr_conv, val_ref);
24472 uint64_t __attribute__((export_name("TS_WatchedOutput_get_outpoint"))) TS_WatchedOutput_get_outpoint(uint64_t this_ptr) {
24473 LDKWatchedOutput this_ptr_conv;
24474 this_ptr_conv.inner = untag_ptr(this_ptr);
24475 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24477 this_ptr_conv.is_owned = false;
24478 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
24479 uint64_t ret_ref = 0;
24480 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24481 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24485 void __attribute__((export_name("TS_WatchedOutput_set_outpoint"))) TS_WatchedOutput_set_outpoint(uint64_t this_ptr, uint64_t val) {
24486 LDKWatchedOutput this_ptr_conv;
24487 this_ptr_conv.inner = untag_ptr(this_ptr);
24488 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24490 this_ptr_conv.is_owned = false;
24491 LDKOutPoint val_conv;
24492 val_conv.inner = untag_ptr(val);
24493 val_conv.is_owned = ptr_is_owned(val);
24494 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24495 val_conv = OutPoint_clone(&val_conv);
24496 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
24499 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_script_pubkey"))) TS_WatchedOutput_get_script_pubkey(uint64_t this_ptr) {
24500 LDKWatchedOutput this_ptr_conv;
24501 this_ptr_conv.inner = untag_ptr(this_ptr);
24502 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24504 this_ptr_conv.is_owned = false;
24505 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
24506 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24507 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24511 void __attribute__((export_name("TS_WatchedOutput_set_script_pubkey"))) TS_WatchedOutput_set_script_pubkey(uint64_t this_ptr, int8_tArray val) {
24512 LDKWatchedOutput this_ptr_conv;
24513 this_ptr_conv.inner = untag_ptr(this_ptr);
24514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24516 this_ptr_conv.is_owned = false;
24517 LDKCVec_u8Z val_ref;
24518 val_ref.datalen = val->arr_len;
24519 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
24520 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
24521 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
24524 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) {
24525 LDKThirtyTwoBytes block_hash_arg_ref;
24526 CHECK(block_hash_arg->arr_len == 32);
24527 memcpy(block_hash_arg_ref.data, block_hash_arg->elems, 32); FREE(block_hash_arg);
24528 LDKOutPoint outpoint_arg_conv;
24529 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
24530 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
24531 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
24532 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
24533 LDKCVec_u8Z script_pubkey_arg_ref;
24534 script_pubkey_arg_ref.datalen = script_pubkey_arg->arr_len;
24535 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
24536 memcpy(script_pubkey_arg_ref.data, script_pubkey_arg->elems, script_pubkey_arg_ref.datalen); FREE(script_pubkey_arg);
24537 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_ref, outpoint_arg_conv, script_pubkey_arg_ref);
24538 uint64_t ret_ref = 0;
24539 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24540 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24544 static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
24545 LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
24546 uint64_t ret_ref = 0;
24547 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24548 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24551 int64_t __attribute__((export_name("TS_WatchedOutput_clone_ptr"))) TS_WatchedOutput_clone_ptr(uint64_t arg) {
24552 LDKWatchedOutput arg_conv;
24553 arg_conv.inner = untag_ptr(arg);
24554 arg_conv.is_owned = ptr_is_owned(arg);
24555 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24556 arg_conv.is_owned = false;
24557 int64_t ret_conv = WatchedOutput_clone_ptr(&arg_conv);
24561 uint64_t __attribute__((export_name("TS_WatchedOutput_clone"))) TS_WatchedOutput_clone(uint64_t orig) {
24562 LDKWatchedOutput orig_conv;
24563 orig_conv.inner = untag_ptr(orig);
24564 orig_conv.is_owned = ptr_is_owned(orig);
24565 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24566 orig_conv.is_owned = false;
24567 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
24568 uint64_t ret_ref = 0;
24569 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24570 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24574 jboolean __attribute__((export_name("TS_WatchedOutput_eq"))) TS_WatchedOutput_eq(uint64_t a, uint64_t b) {
24575 LDKWatchedOutput a_conv;
24576 a_conv.inner = untag_ptr(a);
24577 a_conv.is_owned = ptr_is_owned(a);
24578 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24579 a_conv.is_owned = false;
24580 LDKWatchedOutput b_conv;
24581 b_conv.inner = untag_ptr(b);
24582 b_conv.is_owned = ptr_is_owned(b);
24583 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24584 b_conv.is_owned = false;
24585 jboolean ret_conv = WatchedOutput_eq(&a_conv, &b_conv);
24589 int64_t __attribute__((export_name("TS_WatchedOutput_hash"))) TS_WatchedOutput_hash(uint64_t o) {
24590 LDKWatchedOutput o_conv;
24591 o_conv.inner = untag_ptr(o);
24592 o_conv.is_owned = ptr_is_owned(o);
24593 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24594 o_conv.is_owned = false;
24595 int64_t ret_conv = WatchedOutput_hash(&o_conv);
24599 void __attribute__((export_name("TS_BroadcasterInterface_free"))) TS_BroadcasterInterface_free(uint64_t this_ptr) {
24600 if (!ptr_is_owned(this_ptr)) return;
24601 void* this_ptr_ptr = untag_ptr(this_ptr);
24602 CHECK_ACCESS(this_ptr_ptr);
24603 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(this_ptr_ptr);
24604 FREE(untag_ptr(this_ptr));
24605 BroadcasterInterface_free(this_ptr_conv);
24608 uint32_t __attribute__((export_name("TS_ConfirmationTarget_clone"))) TS_ConfirmationTarget_clone(uint64_t orig) {
24609 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)untag_ptr(orig);
24610 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_clone(orig_conv));
24614 uint32_t __attribute__((export_name("TS_ConfirmationTarget_background"))) TS_ConfirmationTarget_background() {
24615 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_background());
24619 uint32_t __attribute__((export_name("TS_ConfirmationTarget_normal"))) TS_ConfirmationTarget_normal() {
24620 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_normal());
24624 uint32_t __attribute__((export_name("TS_ConfirmationTarget_high_priority"))) TS_ConfirmationTarget_high_priority() {
24625 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_high_priority());
24629 int64_t __attribute__((export_name("TS_ConfirmationTarget_hash"))) TS_ConfirmationTarget_hash(uint64_t o) {
24630 LDKConfirmationTarget* o_conv = (LDKConfirmationTarget*)untag_ptr(o);
24631 int64_t ret_conv = ConfirmationTarget_hash(o_conv);
24635 jboolean __attribute__((export_name("TS_ConfirmationTarget_eq"))) TS_ConfirmationTarget_eq(uint64_t a, uint64_t b) {
24636 LDKConfirmationTarget* a_conv = (LDKConfirmationTarget*)untag_ptr(a);
24637 LDKConfirmationTarget* b_conv = (LDKConfirmationTarget*)untag_ptr(b);
24638 jboolean ret_conv = ConfirmationTarget_eq(a_conv, b_conv);
24642 void __attribute__((export_name("TS_FeeEstimator_free"))) TS_FeeEstimator_free(uint64_t this_ptr) {
24643 if (!ptr_is_owned(this_ptr)) return;
24644 void* this_ptr_ptr = untag_ptr(this_ptr);
24645 CHECK_ACCESS(this_ptr_ptr);
24646 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(this_ptr_ptr);
24647 FREE(untag_ptr(this_ptr));
24648 FeeEstimator_free(this_ptr_conv);
24651 void __attribute__((export_name("TS_MonitorUpdateId_free"))) TS_MonitorUpdateId_free(uint64_t this_obj) {
24652 LDKMonitorUpdateId this_obj_conv;
24653 this_obj_conv.inner = untag_ptr(this_obj);
24654 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24656 MonitorUpdateId_free(this_obj_conv);
24659 static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
24660 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
24661 uint64_t ret_ref = 0;
24662 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24663 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24666 int64_t __attribute__((export_name("TS_MonitorUpdateId_clone_ptr"))) TS_MonitorUpdateId_clone_ptr(uint64_t arg) {
24667 LDKMonitorUpdateId arg_conv;
24668 arg_conv.inner = untag_ptr(arg);
24669 arg_conv.is_owned = ptr_is_owned(arg);
24670 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24671 arg_conv.is_owned = false;
24672 int64_t ret_conv = MonitorUpdateId_clone_ptr(&arg_conv);
24676 uint64_t __attribute__((export_name("TS_MonitorUpdateId_clone"))) TS_MonitorUpdateId_clone(uint64_t orig) {
24677 LDKMonitorUpdateId orig_conv;
24678 orig_conv.inner = untag_ptr(orig);
24679 orig_conv.is_owned = ptr_is_owned(orig);
24680 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24681 orig_conv.is_owned = false;
24682 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
24683 uint64_t ret_ref = 0;
24684 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24685 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24689 int64_t __attribute__((export_name("TS_MonitorUpdateId_hash"))) TS_MonitorUpdateId_hash(uint64_t o) {
24690 LDKMonitorUpdateId o_conv;
24691 o_conv.inner = untag_ptr(o);
24692 o_conv.is_owned = ptr_is_owned(o);
24693 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24694 o_conv.is_owned = false;
24695 int64_t ret_conv = MonitorUpdateId_hash(&o_conv);
24699 jboolean __attribute__((export_name("TS_MonitorUpdateId_eq"))) TS_MonitorUpdateId_eq(uint64_t a, uint64_t b) {
24700 LDKMonitorUpdateId a_conv;
24701 a_conv.inner = untag_ptr(a);
24702 a_conv.is_owned = ptr_is_owned(a);
24703 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24704 a_conv.is_owned = false;
24705 LDKMonitorUpdateId b_conv;
24706 b_conv.inner = untag_ptr(b);
24707 b_conv.is_owned = ptr_is_owned(b);
24708 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24709 b_conv.is_owned = false;
24710 jboolean ret_conv = MonitorUpdateId_eq(&a_conv, &b_conv);
24714 void __attribute__((export_name("TS_Persist_free"))) TS_Persist_free(uint64_t this_ptr) {
24715 if (!ptr_is_owned(this_ptr)) return;
24716 void* this_ptr_ptr = untag_ptr(this_ptr);
24717 CHECK_ACCESS(this_ptr_ptr);
24718 LDKPersist this_ptr_conv = *(LDKPersist*)(this_ptr_ptr);
24719 FREE(untag_ptr(this_ptr));
24720 Persist_free(this_ptr_conv);
24723 void __attribute__((export_name("TS_LockedChannelMonitor_free"))) TS_LockedChannelMonitor_free(uint64_t this_obj) {
24724 LDKLockedChannelMonitor this_obj_conv;
24725 this_obj_conv.inner = untag_ptr(this_obj);
24726 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24728 LockedChannelMonitor_free(this_obj_conv);
24731 void __attribute__((export_name("TS_ChainMonitor_free"))) TS_ChainMonitor_free(uint64_t this_obj) {
24732 LDKChainMonitor this_obj_conv;
24733 this_obj_conv.inner = untag_ptr(this_obj);
24734 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24735 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24736 ChainMonitor_free(this_obj_conv);
24739 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) {
24740 void* chain_source_ptr = untag_ptr(chain_source);
24741 CHECK_ACCESS(chain_source_ptr);
24742 LDKCOption_FilterZ chain_source_conv = *(LDKCOption_FilterZ*)(chain_source_ptr);
24743 // WARNING: we may need a move here but no clone is available for LDKCOption_FilterZ
24744 if (chain_source_conv.tag == LDKCOption_FilterZ_Some) {
24745 // Manually implement clone for Java trait instances
24746 if (chain_source_conv.some.free == LDKFilter_JCalls_free) {
24747 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24748 LDKFilter_JCalls_cloned(&chain_source_conv.some);
24751 void* broadcaster_ptr = untag_ptr(broadcaster);
24752 CHECK_ACCESS(broadcaster_ptr);
24753 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24754 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24755 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24756 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24758 void* logger_ptr = untag_ptr(logger);
24759 CHECK_ACCESS(logger_ptr);
24760 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24761 if (logger_conv.free == LDKLogger_JCalls_free) {
24762 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24763 LDKLogger_JCalls_cloned(&logger_conv);
24765 void* feeest_ptr = untag_ptr(feeest);
24766 CHECK_ACCESS(feeest_ptr);
24767 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(feeest_ptr);
24768 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
24769 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24770 LDKFeeEstimator_JCalls_cloned(&feeest_conv);
24772 void* persister_ptr = untag_ptr(persister);
24773 CHECK_ACCESS(persister_ptr);
24774 LDKPersist persister_conv = *(LDKPersist*)(persister_ptr);
24775 if (persister_conv.free == LDKPersist_JCalls_free) {
24776 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24777 LDKPersist_JCalls_cloned(&persister_conv);
24779 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
24780 uint64_t ret_ref = 0;
24781 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24782 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24786 uint64_tArray __attribute__((export_name("TS_ChainMonitor_get_claimable_balances"))) TS_ChainMonitor_get_claimable_balances(uint64_t this_arg, uint64_tArray ignored_channels) {
24787 LDKChainMonitor this_arg_conv;
24788 this_arg_conv.inner = untag_ptr(this_arg);
24789 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24790 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24791 this_arg_conv.is_owned = false;
24792 LDKCVec_ChannelDetailsZ ignored_channels_constr;
24793 ignored_channels_constr.datalen = ignored_channels->arr_len;
24794 if (ignored_channels_constr.datalen > 0)
24795 ignored_channels_constr.data = MALLOC(ignored_channels_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
24797 ignored_channels_constr.data = NULL;
24798 uint64_t* ignored_channels_vals = ignored_channels->elems;
24799 for (size_t q = 0; q < ignored_channels_constr.datalen; q++) {
24800 uint64_t ignored_channels_conv_16 = ignored_channels_vals[q];
24801 LDKChannelDetails ignored_channels_conv_16_conv;
24802 ignored_channels_conv_16_conv.inner = untag_ptr(ignored_channels_conv_16);
24803 ignored_channels_conv_16_conv.is_owned = ptr_is_owned(ignored_channels_conv_16);
24804 CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
24805 ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
24806 ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
24808 FREE(ignored_channels);
24809 LDKCVec_BalanceZ ret_var = ChainMonitor_get_claimable_balances(&this_arg_conv, ignored_channels_constr);
24810 uint64_tArray ret_arr = NULL;
24811 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24812 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24813 for (size_t j = 0; j < ret_var.datalen; j++) {
24814 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
24815 *ret_conv_9_copy = ret_var.data[j];
24816 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
24817 ret_arr_ptr[j] = ret_conv_9_ref;
24820 FREE(ret_var.data);
24824 uint64_t __attribute__((export_name("TS_ChainMonitor_get_monitor"))) TS_ChainMonitor_get_monitor(uint64_t this_arg, uint64_t funding_txo) {
24825 LDKChainMonitor this_arg_conv;
24826 this_arg_conv.inner = untag_ptr(this_arg);
24827 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24828 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24829 this_arg_conv.is_owned = false;
24830 LDKOutPoint funding_txo_conv;
24831 funding_txo_conv.inner = untag_ptr(funding_txo);
24832 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24833 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24834 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24835 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
24836 *ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
24837 return tag_ptr(ret_conv, true);
24840 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_monitors"))) TS_ChainMonitor_list_monitors(uint64_t this_arg) {
24841 LDKChainMonitor this_arg_conv;
24842 this_arg_conv.inner = untag_ptr(this_arg);
24843 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24844 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24845 this_arg_conv.is_owned = false;
24846 LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
24847 uint64_tArray ret_arr = NULL;
24848 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24849 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24850 for (size_t k = 0; k < ret_var.datalen; k++) {
24851 LDKOutPoint ret_conv_10_var = ret_var.data[k];
24852 uint64_t ret_conv_10_ref = 0;
24853 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
24854 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
24855 ret_arr_ptr[k] = ret_conv_10_ref;
24858 FREE(ret_var.data);
24862 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_pending_monitor_updates"))) TS_ChainMonitor_list_pending_monitor_updates(uint64_t this_arg) {
24863 LDKChainMonitor this_arg_conv;
24864 this_arg_conv.inner = untag_ptr(this_arg);
24865 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24867 this_arg_conv.is_owned = false;
24868 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret_var = ChainMonitor_list_pending_monitor_updates(&this_arg_conv);
24869 uint64_tArray ret_arr = NULL;
24870 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
24871 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
24872 for (size_t p = 0; p < ret_var.datalen; p++) {
24873 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv_41_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
24874 *ret_conv_41_conv = ret_var.data[p];
24875 ret_arr_ptr[p] = tag_ptr(ret_conv_41_conv, true);
24878 FREE(ret_var.data);
24882 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) {
24883 LDKChainMonitor this_arg_conv;
24884 this_arg_conv.inner = untag_ptr(this_arg);
24885 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24887 this_arg_conv.is_owned = false;
24888 LDKOutPoint funding_txo_conv;
24889 funding_txo_conv.inner = untag_ptr(funding_txo);
24890 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
24891 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
24892 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
24893 LDKMonitorUpdateId completed_update_id_conv;
24894 completed_update_id_conv.inner = untag_ptr(completed_update_id);
24895 completed_update_id_conv.is_owned = ptr_is_owned(completed_update_id);
24896 CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
24897 completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
24898 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
24899 *ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
24900 return tag_ptr(ret_conv, true);
24903 uint64_t __attribute__((export_name("TS_ChainMonitor_get_update_future"))) TS_ChainMonitor_get_update_future(uint64_t this_arg) {
24904 LDKChainMonitor this_arg_conv;
24905 this_arg_conv.inner = untag_ptr(this_arg);
24906 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24907 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24908 this_arg_conv.is_owned = false;
24909 LDKFuture ret_var = ChainMonitor_get_update_future(&this_arg_conv);
24910 uint64_t ret_ref = 0;
24911 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24912 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
24916 void __attribute__((export_name("TS_ChainMonitor_rebroadcast_pending_claims"))) TS_ChainMonitor_rebroadcast_pending_claims(uint64_t this_arg) {
24917 LDKChainMonitor this_arg_conv;
24918 this_arg_conv.inner = untag_ptr(this_arg);
24919 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24921 this_arg_conv.is_owned = false;
24922 ChainMonitor_rebroadcast_pending_claims(&this_arg_conv);
24925 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Listen"))) TS_ChainMonitor_as_Listen(uint64_t this_arg) {
24926 LDKChainMonitor this_arg_conv;
24927 this_arg_conv.inner = untag_ptr(this_arg);
24928 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24930 this_arg_conv.is_owned = false;
24931 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
24932 *ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
24933 return tag_ptr(ret_ret, true);
24936 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Confirm"))) TS_ChainMonitor_as_Confirm(uint64_t this_arg) {
24937 LDKChainMonitor this_arg_conv;
24938 this_arg_conv.inner = untag_ptr(this_arg);
24939 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24941 this_arg_conv.is_owned = false;
24942 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
24943 *ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
24944 return tag_ptr(ret_ret, true);
24947 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Watch"))) TS_ChainMonitor_as_Watch(uint64_t this_arg) {
24948 LDKChainMonitor this_arg_conv;
24949 this_arg_conv.inner = untag_ptr(this_arg);
24950 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24952 this_arg_conv.is_owned = false;
24953 LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
24954 *ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
24955 return tag_ptr(ret_ret, true);
24958 uint64_t __attribute__((export_name("TS_ChainMonitor_as_EventsProvider"))) TS_ChainMonitor_as_EventsProvider(uint64_t this_arg) {
24959 LDKChainMonitor this_arg_conv;
24960 this_arg_conv.inner = untag_ptr(this_arg);
24961 this_arg_conv.is_owned = ptr_is_owned(this_arg);
24962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24963 this_arg_conv.is_owned = false;
24964 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
24965 *ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
24966 return tag_ptr(ret_ret, true);
24969 void __attribute__((export_name("TS_ChannelMonitorUpdate_free"))) TS_ChannelMonitorUpdate_free(uint64_t this_obj) {
24970 LDKChannelMonitorUpdate this_obj_conv;
24971 this_obj_conv.inner = untag_ptr(this_obj);
24972 this_obj_conv.is_owned = ptr_is_owned(this_obj);
24973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24974 ChannelMonitorUpdate_free(this_obj_conv);
24977 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_get_update_id"))) TS_ChannelMonitorUpdate_get_update_id(uint64_t this_ptr) {
24978 LDKChannelMonitorUpdate this_ptr_conv;
24979 this_ptr_conv.inner = untag_ptr(this_ptr);
24980 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24982 this_ptr_conv.is_owned = false;
24983 int64_t ret_conv = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
24987 void __attribute__((export_name("TS_ChannelMonitorUpdate_set_update_id"))) TS_ChannelMonitorUpdate_set_update_id(uint64_t this_ptr, int64_t val) {
24988 LDKChannelMonitorUpdate this_ptr_conv;
24989 this_ptr_conv.inner = untag_ptr(this_ptr);
24990 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
24991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24992 this_ptr_conv.is_owned = false;
24993 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
24996 static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
24997 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
24998 uint64_t ret_ref = 0;
24999 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25000 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25003 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone_ptr"))) TS_ChannelMonitorUpdate_clone_ptr(uint64_t arg) {
25004 LDKChannelMonitorUpdate arg_conv;
25005 arg_conv.inner = untag_ptr(arg);
25006 arg_conv.is_owned = ptr_is_owned(arg);
25007 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25008 arg_conv.is_owned = false;
25009 int64_t ret_conv = ChannelMonitorUpdate_clone_ptr(&arg_conv);
25013 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone"))) TS_ChannelMonitorUpdate_clone(uint64_t orig) {
25014 LDKChannelMonitorUpdate orig_conv;
25015 orig_conv.inner = untag_ptr(orig);
25016 orig_conv.is_owned = ptr_is_owned(orig);
25017 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25018 orig_conv.is_owned = false;
25019 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
25020 uint64_t ret_ref = 0;
25021 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25022 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25026 jboolean __attribute__((export_name("TS_ChannelMonitorUpdate_eq"))) TS_ChannelMonitorUpdate_eq(uint64_t a, uint64_t b) {
25027 LDKChannelMonitorUpdate a_conv;
25028 a_conv.inner = untag_ptr(a);
25029 a_conv.is_owned = ptr_is_owned(a);
25030 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25031 a_conv.is_owned = false;
25032 LDKChannelMonitorUpdate b_conv;
25033 b_conv.inner = untag_ptr(b);
25034 b_conv.is_owned = ptr_is_owned(b);
25035 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25036 b_conv.is_owned = false;
25037 jboolean ret_conv = ChannelMonitorUpdate_eq(&a_conv, &b_conv);
25041 int8_tArray __attribute__((export_name("TS_ChannelMonitorUpdate_write"))) TS_ChannelMonitorUpdate_write(uint64_t obj) {
25042 LDKChannelMonitorUpdate obj_conv;
25043 obj_conv.inner = untag_ptr(obj);
25044 obj_conv.is_owned = ptr_is_owned(obj);
25045 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25046 obj_conv.is_owned = false;
25047 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
25048 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25049 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25050 CVec_u8Z_free(ret_var);
25054 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_read"))) TS_ChannelMonitorUpdate_read(int8_tArray ser) {
25055 LDKu8slice ser_ref;
25056 ser_ref.datalen = ser->arr_len;
25057 ser_ref.data = ser->elems;
25058 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
25059 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
25061 return tag_ptr(ret_conv, true);
25064 void __attribute__((export_name("TS_MonitorEvent_free"))) TS_MonitorEvent_free(uint64_t this_ptr) {
25065 if (!ptr_is_owned(this_ptr)) return;
25066 void* this_ptr_ptr = untag_ptr(this_ptr);
25067 CHECK_ACCESS(this_ptr_ptr);
25068 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(this_ptr_ptr);
25069 FREE(untag_ptr(this_ptr));
25070 MonitorEvent_free(this_ptr_conv);
25073 static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
25074 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25075 *ret_copy = MonitorEvent_clone(arg);
25076 uint64_t ret_ref = tag_ptr(ret_copy, true);
25079 int64_t __attribute__((export_name("TS_MonitorEvent_clone_ptr"))) TS_MonitorEvent_clone_ptr(uint64_t arg) {
25080 LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)untag_ptr(arg);
25081 int64_t ret_conv = MonitorEvent_clone_ptr(arg_conv);
25085 uint64_t __attribute__((export_name("TS_MonitorEvent_clone"))) TS_MonitorEvent_clone(uint64_t orig) {
25086 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)untag_ptr(orig);
25087 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25088 *ret_copy = MonitorEvent_clone(orig_conv);
25089 uint64_t ret_ref = tag_ptr(ret_copy, true);
25093 uint64_t __attribute__((export_name("TS_MonitorEvent_htlcevent"))) TS_MonitorEvent_htlcevent(uint64_t a) {
25094 LDKHTLCUpdate a_conv;
25095 a_conv.inner = untag_ptr(a);
25096 a_conv.is_owned = ptr_is_owned(a);
25097 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25098 a_conv = HTLCUpdate_clone(&a_conv);
25099 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25100 *ret_copy = MonitorEvent_htlcevent(a_conv);
25101 uint64_t ret_ref = tag_ptr(ret_copy, true);
25105 uint64_t __attribute__((export_name("TS_MonitorEvent_commitment_tx_confirmed"))) TS_MonitorEvent_commitment_tx_confirmed(uint64_t a) {
25106 LDKOutPoint a_conv;
25107 a_conv.inner = untag_ptr(a);
25108 a_conv.is_owned = ptr_is_owned(a);
25109 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25110 a_conv = OutPoint_clone(&a_conv);
25111 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25112 *ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
25113 uint64_t ret_ref = tag_ptr(ret_copy, true);
25117 uint64_t __attribute__((export_name("TS_MonitorEvent_completed"))) TS_MonitorEvent_completed(uint64_t funding_txo, int64_t monitor_update_id) {
25118 LDKOutPoint funding_txo_conv;
25119 funding_txo_conv.inner = untag_ptr(funding_txo);
25120 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
25121 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
25122 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
25123 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25124 *ret_copy = MonitorEvent_completed(funding_txo_conv, monitor_update_id);
25125 uint64_t ret_ref = tag_ptr(ret_copy, true);
25129 uint64_t __attribute__((export_name("TS_MonitorEvent_update_failed"))) TS_MonitorEvent_update_failed(uint64_t a) {
25130 LDKOutPoint a_conv;
25131 a_conv.inner = untag_ptr(a);
25132 a_conv.is_owned = ptr_is_owned(a);
25133 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25134 a_conv = OutPoint_clone(&a_conv);
25135 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25136 *ret_copy = MonitorEvent_update_failed(a_conv);
25137 uint64_t ret_ref = tag_ptr(ret_copy, true);
25141 jboolean __attribute__((export_name("TS_MonitorEvent_eq"))) TS_MonitorEvent_eq(uint64_t a, uint64_t b) {
25142 LDKMonitorEvent* a_conv = (LDKMonitorEvent*)untag_ptr(a);
25143 LDKMonitorEvent* b_conv = (LDKMonitorEvent*)untag_ptr(b);
25144 jboolean ret_conv = MonitorEvent_eq(a_conv, b_conv);
25148 int8_tArray __attribute__((export_name("TS_MonitorEvent_write"))) TS_MonitorEvent_write(uint64_t obj) {
25149 LDKMonitorEvent* obj_conv = (LDKMonitorEvent*)untag_ptr(obj);
25150 LDKCVec_u8Z ret_var = MonitorEvent_write(obj_conv);
25151 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25152 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25153 CVec_u8Z_free(ret_var);
25157 uint64_t __attribute__((export_name("TS_MonitorEvent_read"))) TS_MonitorEvent_read(int8_tArray ser) {
25158 LDKu8slice ser_ref;
25159 ser_ref.datalen = ser->arr_len;
25160 ser_ref.data = ser->elems;
25161 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
25162 *ret_conv = MonitorEvent_read(ser_ref);
25164 return tag_ptr(ret_conv, true);
25167 void __attribute__((export_name("TS_HTLCUpdate_free"))) TS_HTLCUpdate_free(uint64_t this_obj) {
25168 LDKHTLCUpdate this_obj_conv;
25169 this_obj_conv.inner = untag_ptr(this_obj);
25170 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25172 HTLCUpdate_free(this_obj_conv);
25175 static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
25176 LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
25177 uint64_t ret_ref = 0;
25178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25179 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25182 int64_t __attribute__((export_name("TS_HTLCUpdate_clone_ptr"))) TS_HTLCUpdate_clone_ptr(uint64_t arg) {
25183 LDKHTLCUpdate arg_conv;
25184 arg_conv.inner = untag_ptr(arg);
25185 arg_conv.is_owned = ptr_is_owned(arg);
25186 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25187 arg_conv.is_owned = false;
25188 int64_t ret_conv = HTLCUpdate_clone_ptr(&arg_conv);
25192 uint64_t __attribute__((export_name("TS_HTLCUpdate_clone"))) TS_HTLCUpdate_clone(uint64_t orig) {
25193 LDKHTLCUpdate orig_conv;
25194 orig_conv.inner = untag_ptr(orig);
25195 orig_conv.is_owned = ptr_is_owned(orig);
25196 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25197 orig_conv.is_owned = false;
25198 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
25199 uint64_t ret_ref = 0;
25200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25201 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25205 jboolean __attribute__((export_name("TS_HTLCUpdate_eq"))) TS_HTLCUpdate_eq(uint64_t a, uint64_t b) {
25206 LDKHTLCUpdate a_conv;
25207 a_conv.inner = untag_ptr(a);
25208 a_conv.is_owned = ptr_is_owned(a);
25209 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25210 a_conv.is_owned = false;
25211 LDKHTLCUpdate b_conv;
25212 b_conv.inner = untag_ptr(b);
25213 b_conv.is_owned = ptr_is_owned(b);
25214 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25215 b_conv.is_owned = false;
25216 jboolean ret_conv = HTLCUpdate_eq(&a_conv, &b_conv);
25220 int8_tArray __attribute__((export_name("TS_HTLCUpdate_write"))) TS_HTLCUpdate_write(uint64_t obj) {
25221 LDKHTLCUpdate obj_conv;
25222 obj_conv.inner = untag_ptr(obj);
25223 obj_conv.is_owned = ptr_is_owned(obj);
25224 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25225 obj_conv.is_owned = false;
25226 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
25227 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25228 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25229 CVec_u8Z_free(ret_var);
25233 uint64_t __attribute__((export_name("TS_HTLCUpdate_read"))) TS_HTLCUpdate_read(int8_tArray ser) {
25234 LDKu8slice ser_ref;
25235 ser_ref.datalen = ser->arr_len;
25236 ser_ref.data = ser->elems;
25237 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
25238 *ret_conv = HTLCUpdate_read(ser_ref);
25240 return tag_ptr(ret_conv, true);
25243 void __attribute__((export_name("TS_Balance_free"))) TS_Balance_free(uint64_t this_ptr) {
25244 if (!ptr_is_owned(this_ptr)) return;
25245 void* this_ptr_ptr = untag_ptr(this_ptr);
25246 CHECK_ACCESS(this_ptr_ptr);
25247 LDKBalance this_ptr_conv = *(LDKBalance*)(this_ptr_ptr);
25248 FREE(untag_ptr(this_ptr));
25249 Balance_free(this_ptr_conv);
25252 static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
25253 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25254 *ret_copy = Balance_clone(arg);
25255 uint64_t ret_ref = tag_ptr(ret_copy, true);
25258 int64_t __attribute__((export_name("TS_Balance_clone_ptr"))) TS_Balance_clone_ptr(uint64_t arg) {
25259 LDKBalance* arg_conv = (LDKBalance*)untag_ptr(arg);
25260 int64_t ret_conv = Balance_clone_ptr(arg_conv);
25264 uint64_t __attribute__((export_name("TS_Balance_clone"))) TS_Balance_clone(uint64_t orig) {
25265 LDKBalance* orig_conv = (LDKBalance*)untag_ptr(orig);
25266 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25267 *ret_copy = Balance_clone(orig_conv);
25268 uint64_t ret_ref = tag_ptr(ret_copy, true);
25272 uint64_t __attribute__((export_name("TS_Balance_claimable_on_channel_close"))) TS_Balance_claimable_on_channel_close(int64_t claimable_amount_satoshis) {
25273 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25274 *ret_copy = Balance_claimable_on_channel_close(claimable_amount_satoshis);
25275 uint64_t ret_ref = tag_ptr(ret_copy, true);
25279 uint64_t __attribute__((export_name("TS_Balance_claimable_awaiting_confirmations"))) TS_Balance_claimable_awaiting_confirmations(int64_t claimable_amount_satoshis, int32_t confirmation_height) {
25280 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25281 *ret_copy = Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
25282 uint64_t ret_ref = tag_ptr(ret_copy, true);
25286 uint64_t __attribute__((export_name("TS_Balance_contentious_claimable"))) TS_Balance_contentious_claimable(int64_t claimable_amount_satoshis, int32_t timeout_height) {
25287 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25288 *ret_copy = Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
25289 uint64_t ret_ref = tag_ptr(ret_copy, true);
25293 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) {
25294 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25295 *ret_copy = Balance_maybe_timeout_claimable_htlc(claimable_amount_satoshis, claimable_height);
25296 uint64_t ret_ref = tag_ptr(ret_copy, true);
25300 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) {
25301 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25302 *ret_copy = Balance_maybe_preimage_claimable_htlc(claimable_amount_satoshis, expiry_height);
25303 uint64_t ret_ref = tag_ptr(ret_copy, true);
25307 uint64_t __attribute__((export_name("TS_Balance_counterparty_revoked_output_claimable"))) TS_Balance_counterparty_revoked_output_claimable(int64_t claimable_amount_satoshis) {
25308 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25309 *ret_copy = Balance_counterparty_revoked_output_claimable(claimable_amount_satoshis);
25310 uint64_t ret_ref = tag_ptr(ret_copy, true);
25314 jboolean __attribute__((export_name("TS_Balance_eq"))) TS_Balance_eq(uint64_t a, uint64_t b) {
25315 LDKBalance* a_conv = (LDKBalance*)untag_ptr(a);
25316 LDKBalance* b_conv = (LDKBalance*)untag_ptr(b);
25317 jboolean ret_conv = Balance_eq(a_conv, b_conv);
25321 void __attribute__((export_name("TS_ChannelMonitor_free"))) TS_ChannelMonitor_free(uint64_t this_obj) {
25322 LDKChannelMonitor this_obj_conv;
25323 this_obj_conv.inner = untag_ptr(this_obj);
25324 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25326 ChannelMonitor_free(this_obj_conv);
25329 static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
25330 LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
25331 uint64_t ret_ref = 0;
25332 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25333 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25336 int64_t __attribute__((export_name("TS_ChannelMonitor_clone_ptr"))) TS_ChannelMonitor_clone_ptr(uint64_t arg) {
25337 LDKChannelMonitor arg_conv;
25338 arg_conv.inner = untag_ptr(arg);
25339 arg_conv.is_owned = ptr_is_owned(arg);
25340 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25341 arg_conv.is_owned = false;
25342 int64_t ret_conv = ChannelMonitor_clone_ptr(&arg_conv);
25346 uint64_t __attribute__((export_name("TS_ChannelMonitor_clone"))) TS_ChannelMonitor_clone(uint64_t orig) {
25347 LDKChannelMonitor orig_conv;
25348 orig_conv.inner = untag_ptr(orig);
25349 orig_conv.is_owned = ptr_is_owned(orig);
25350 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25351 orig_conv.is_owned = false;
25352 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
25353 uint64_t ret_ref = 0;
25354 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25355 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25359 int8_tArray __attribute__((export_name("TS_ChannelMonitor_write"))) TS_ChannelMonitor_write(uint64_t obj) {
25360 LDKChannelMonitor obj_conv;
25361 obj_conv.inner = untag_ptr(obj);
25362 obj_conv.is_owned = ptr_is_owned(obj);
25363 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25364 obj_conv.is_owned = false;
25365 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
25366 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25367 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25368 CVec_u8Z_free(ret_var);
25372 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) {
25373 LDKChannelMonitor this_arg_conv;
25374 this_arg_conv.inner = untag_ptr(this_arg);
25375 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25377 this_arg_conv.is_owned = false;
25378 LDKChannelMonitorUpdate updates_conv;
25379 updates_conv.inner = untag_ptr(updates);
25380 updates_conv.is_owned = ptr_is_owned(updates);
25381 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
25382 updates_conv.is_owned = false;
25383 void* broadcaster_ptr = untag_ptr(broadcaster);
25384 if (ptr_is_owned(broadcaster)) { CHECK_ACCESS(broadcaster_ptr); }
25385 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
25386 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25387 CHECK_ACCESS(fee_estimator_ptr);
25388 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25389 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25390 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25391 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25393 void* logger_ptr = untag_ptr(logger);
25394 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
25395 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
25396 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
25397 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
25398 return tag_ptr(ret_conv, true);
25401 int64_t __attribute__((export_name("TS_ChannelMonitor_get_latest_update_id"))) TS_ChannelMonitor_get_latest_update_id(uint64_t this_arg) {
25402 LDKChannelMonitor this_arg_conv;
25403 this_arg_conv.inner = untag_ptr(this_arg);
25404 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25406 this_arg_conv.is_owned = false;
25407 int64_t ret_conv = ChannelMonitor_get_latest_update_id(&this_arg_conv);
25411 uint64_t __attribute__((export_name("TS_ChannelMonitor_get_funding_txo"))) TS_ChannelMonitor_get_funding_txo(uint64_t this_arg) {
25412 LDKChannelMonitor this_arg_conv;
25413 this_arg_conv.inner = untag_ptr(this_arg);
25414 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25415 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25416 this_arg_conv.is_owned = false;
25417 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
25418 *ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
25419 return tag_ptr(ret_conv, true);
25422 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_outputs_to_watch"))) TS_ChannelMonitor_get_outputs_to_watch(uint64_t this_arg) {
25423 LDKChannelMonitor this_arg_conv;
25424 this_arg_conv.inner = untag_ptr(this_arg);
25425 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25427 this_arg_conv.is_owned = false;
25428 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
25429 uint64_tArray ret_arr = NULL;
25430 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25431 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25432 for (size_t o = 0; o < ret_var.datalen; o++) {
25433 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
25434 *ret_conv_40_conv = ret_var.data[o];
25435 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
25438 FREE(ret_var.data);
25442 void __attribute__((export_name("TS_ChannelMonitor_load_outputs_to_watch"))) TS_ChannelMonitor_load_outputs_to_watch(uint64_t this_arg, uint64_t filter) {
25443 LDKChannelMonitor this_arg_conv;
25444 this_arg_conv.inner = untag_ptr(this_arg);
25445 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25447 this_arg_conv.is_owned = false;
25448 void* filter_ptr = untag_ptr(filter);
25449 if (ptr_is_owned(filter)) { CHECK_ACCESS(filter_ptr); }
25450 LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
25451 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
25454 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) {
25455 LDKChannelMonitor this_arg_conv;
25456 this_arg_conv.inner = untag_ptr(this_arg);
25457 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25459 this_arg_conv.is_owned = false;
25460 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
25461 uint64_tArray ret_arr = NULL;
25462 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25463 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25464 for (size_t o = 0; o < ret_var.datalen; o++) {
25465 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
25466 *ret_conv_14_copy = ret_var.data[o];
25467 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
25468 ret_arr_ptr[o] = ret_conv_14_ref;
25471 FREE(ret_var.data);
25475 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_and_clear_pending_events"))) TS_ChannelMonitor_get_and_clear_pending_events(uint64_t this_arg) {
25476 LDKChannelMonitor this_arg_conv;
25477 this_arg_conv.inner = untag_ptr(this_arg);
25478 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25480 this_arg_conv.is_owned = false;
25481 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
25482 uint64_tArray ret_arr = NULL;
25483 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25484 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25485 for (size_t h = 0; h < ret_var.datalen; h++) {
25486 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
25487 *ret_conv_7_copy = ret_var.data[h];
25488 uint64_t ret_conv_7_ref = tag_ptr(ret_conv_7_copy, true);
25489 ret_arr_ptr[h] = ret_conv_7_ref;
25492 FREE(ret_var.data);
25496 int8_tArray __attribute__((export_name("TS_ChannelMonitor_get_counterparty_node_id"))) TS_ChannelMonitor_get_counterparty_node_id(uint64_t this_arg) {
25497 LDKChannelMonitor this_arg_conv;
25498 this_arg_conv.inner = untag_ptr(this_arg);
25499 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25501 this_arg_conv.is_owned = false;
25502 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
25503 memcpy(ret_arr->elems, ChannelMonitor_get_counterparty_node_id(&this_arg_conv).compressed_form, 33);
25507 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) {
25508 LDKChannelMonitor this_arg_conv;
25509 this_arg_conv.inner = untag_ptr(this_arg);
25510 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25512 this_arg_conv.is_owned = false;
25513 void* logger_ptr = untag_ptr(logger);
25514 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
25515 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
25516 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
25517 ptrArray ret_arr = NULL;
25518 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
25519 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
25520 for (size_t m = 0; m < ret_var.datalen; m++) {
25521 LDKTransaction ret_conv_12_var = ret_var.data[m];
25522 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
25523 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
25524 Transaction_free(ret_conv_12_var);
25525 ret_arr_ptr[m] = ret_conv_12_arr;
25528 FREE(ret_var.data);
25532 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) {
25533 LDKChannelMonitor this_arg_conv;
25534 this_arg_conv.inner = untag_ptr(this_arg);
25535 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25537 this_arg_conv.is_owned = false;
25538 uint8_t header_arr[80];
25539 CHECK(header->arr_len == 80);
25540 memcpy(header_arr, header->elems, 80); FREE(header);
25541 uint8_t (*header_ref)[80] = &header_arr;
25542 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
25543 txdata_constr.datalen = txdata->arr_len;
25544 if (txdata_constr.datalen > 0)
25545 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
25547 txdata_constr.data = NULL;
25548 uint64_t* txdata_vals = txdata->elems;
25549 for (size_t c = 0; c < txdata_constr.datalen; c++) {
25550 uint64_t txdata_conv_28 = txdata_vals[c];
25551 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
25552 CHECK_ACCESS(txdata_conv_28_ptr);
25553 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
25554 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
25555 txdata_constr.data[c] = txdata_conv_28_conv;
25558 void* broadcaster_ptr = untag_ptr(broadcaster);
25559 CHECK_ACCESS(broadcaster_ptr);
25560 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25561 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25562 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25563 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25565 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25566 CHECK_ACCESS(fee_estimator_ptr);
25567 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25568 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25569 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25570 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25572 void* logger_ptr = untag_ptr(logger);
25573 CHECK_ACCESS(logger_ptr);
25574 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25575 if (logger_conv.free == LDKLogger_JCalls_free) {
25576 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25577 LDKLogger_JCalls_cloned(&logger_conv);
25579 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);
25580 uint64_tArray ret_arr = NULL;
25581 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25582 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25583 for (size_t n = 0; n < ret_var.datalen; n++) {
25584 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25585 *ret_conv_39_conv = ret_var.data[n];
25586 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25589 FREE(ret_var.data);
25593 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) {
25594 LDKChannelMonitor this_arg_conv;
25595 this_arg_conv.inner = untag_ptr(this_arg);
25596 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25597 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25598 this_arg_conv.is_owned = false;
25599 uint8_t header_arr[80];
25600 CHECK(header->arr_len == 80);
25601 memcpy(header_arr, header->elems, 80); FREE(header);
25602 uint8_t (*header_ref)[80] = &header_arr;
25603 void* broadcaster_ptr = untag_ptr(broadcaster);
25604 CHECK_ACCESS(broadcaster_ptr);
25605 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25606 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25607 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25608 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25610 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25611 CHECK_ACCESS(fee_estimator_ptr);
25612 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25613 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25614 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25615 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25617 void* logger_ptr = untag_ptr(logger);
25618 CHECK_ACCESS(logger_ptr);
25619 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25620 if (logger_conv.free == LDKLogger_JCalls_free) {
25621 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25622 LDKLogger_JCalls_cloned(&logger_conv);
25624 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25627 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) {
25628 LDKChannelMonitor this_arg_conv;
25629 this_arg_conv.inner = untag_ptr(this_arg);
25630 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25632 this_arg_conv.is_owned = false;
25633 uint8_t header_arr[80];
25634 CHECK(header->arr_len == 80);
25635 memcpy(header_arr, header->elems, 80); FREE(header);
25636 uint8_t (*header_ref)[80] = &header_arr;
25637 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
25638 txdata_constr.datalen = txdata->arr_len;
25639 if (txdata_constr.datalen > 0)
25640 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
25642 txdata_constr.data = NULL;
25643 uint64_t* txdata_vals = txdata->elems;
25644 for (size_t c = 0; c < txdata_constr.datalen; c++) {
25645 uint64_t txdata_conv_28 = txdata_vals[c];
25646 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
25647 CHECK_ACCESS(txdata_conv_28_ptr);
25648 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
25649 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
25650 txdata_constr.data[c] = txdata_conv_28_conv;
25653 void* broadcaster_ptr = untag_ptr(broadcaster);
25654 CHECK_ACCESS(broadcaster_ptr);
25655 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25656 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25657 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25658 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25660 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25661 CHECK_ACCESS(fee_estimator_ptr);
25662 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25663 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25664 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25665 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25667 void* logger_ptr = untag_ptr(logger);
25668 CHECK_ACCESS(logger_ptr);
25669 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25670 if (logger_conv.free == LDKLogger_JCalls_free) {
25671 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25672 LDKLogger_JCalls_cloned(&logger_conv);
25674 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);
25675 uint64_tArray ret_arr = NULL;
25676 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25677 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25678 for (size_t n = 0; n < ret_var.datalen; n++) {
25679 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25680 *ret_conv_39_conv = ret_var.data[n];
25681 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25684 FREE(ret_var.data);
25688 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) {
25689 LDKChannelMonitor this_arg_conv;
25690 this_arg_conv.inner = untag_ptr(this_arg);
25691 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25693 this_arg_conv.is_owned = false;
25694 uint8_t txid_arr[32];
25695 CHECK(txid->arr_len == 32);
25696 memcpy(txid_arr, txid->elems, 32); FREE(txid);
25697 uint8_t (*txid_ref)[32] = &txid_arr;
25698 void* broadcaster_ptr = untag_ptr(broadcaster);
25699 CHECK_ACCESS(broadcaster_ptr);
25700 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25701 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25702 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25703 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25705 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25706 CHECK_ACCESS(fee_estimator_ptr);
25707 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25708 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25709 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25710 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25712 void* logger_ptr = untag_ptr(logger);
25713 CHECK_ACCESS(logger_ptr);
25714 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25715 if (logger_conv.free == LDKLogger_JCalls_free) {
25716 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25717 LDKLogger_JCalls_cloned(&logger_conv);
25719 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
25722 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) {
25723 LDKChannelMonitor this_arg_conv;
25724 this_arg_conv.inner = untag_ptr(this_arg);
25725 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25726 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25727 this_arg_conv.is_owned = false;
25728 uint8_t header_arr[80];
25729 CHECK(header->arr_len == 80);
25730 memcpy(header_arr, header->elems, 80); FREE(header);
25731 uint8_t (*header_ref)[80] = &header_arr;
25732 void* broadcaster_ptr = untag_ptr(broadcaster);
25733 CHECK_ACCESS(broadcaster_ptr);
25734 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25735 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25736 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25737 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25739 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25740 CHECK_ACCESS(fee_estimator_ptr);
25741 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25742 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25743 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25744 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25746 void* logger_ptr = untag_ptr(logger);
25747 CHECK_ACCESS(logger_ptr);
25748 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25749 if (logger_conv.free == LDKLogger_JCalls_free) {
25750 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25751 LDKLogger_JCalls_cloned(&logger_conv);
25753 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
25754 uint64_tArray ret_arr = NULL;
25755 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25756 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25757 for (size_t n = 0; n < ret_var.datalen; n++) {
25758 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
25759 *ret_conv_39_conv = ret_var.data[n];
25760 ret_arr_ptr[n] = tag_ptr(ret_conv_39_conv, true);
25763 FREE(ret_var.data);
25767 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_relevant_txids"))) TS_ChannelMonitor_get_relevant_txids(uint64_t this_arg) {
25768 LDKChannelMonitor this_arg_conv;
25769 this_arg_conv.inner = untag_ptr(this_arg);
25770 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25772 this_arg_conv.is_owned = false;
25773 LDKCVec_C2Tuple_TxidBlockHashZZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
25774 uint64_tArray ret_arr = NULL;
25775 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25776 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25777 for (size_t z = 0; z < ret_var.datalen; z++) {
25778 LDKC2Tuple_TxidBlockHashZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_TxidBlockHashZ), "LDKC2Tuple_TxidBlockHashZ");
25779 *ret_conv_25_conv = ret_var.data[z];
25780 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
25783 FREE(ret_var.data);
25787 uint64_t __attribute__((export_name("TS_ChannelMonitor_current_best_block"))) TS_ChannelMonitor_current_best_block(uint64_t this_arg) {
25788 LDKChannelMonitor this_arg_conv;
25789 this_arg_conv.inner = untag_ptr(this_arg);
25790 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25792 this_arg_conv.is_owned = false;
25793 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
25794 uint64_t ret_ref = 0;
25795 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25796 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25800 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) {
25801 LDKChannelMonitor this_arg_conv;
25802 this_arg_conv.inner = untag_ptr(this_arg);
25803 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25804 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25805 this_arg_conv.is_owned = false;
25806 void* broadcaster_ptr = untag_ptr(broadcaster);
25807 CHECK_ACCESS(broadcaster_ptr);
25808 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
25809 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
25810 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25811 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
25813 void* fee_estimator_ptr = untag_ptr(fee_estimator);
25814 CHECK_ACCESS(fee_estimator_ptr);
25815 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
25816 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
25817 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25818 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
25820 void* logger_ptr = untag_ptr(logger);
25821 CHECK_ACCESS(logger_ptr);
25822 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
25823 if (logger_conv.free == LDKLogger_JCalls_free) {
25824 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
25825 LDKLogger_JCalls_cloned(&logger_conv);
25827 ChannelMonitor_rebroadcast_pending_claims(&this_arg_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
25830 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_claimable_balances"))) TS_ChannelMonitor_get_claimable_balances(uint64_t this_arg) {
25831 LDKChannelMonitor this_arg_conv;
25832 this_arg_conv.inner = untag_ptr(this_arg);
25833 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25835 this_arg_conv.is_owned = false;
25836 LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
25837 uint64_tArray ret_arr = NULL;
25838 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
25839 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
25840 for (size_t j = 0; j < ret_var.datalen; j++) {
25841 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
25842 *ret_conv_9_copy = ret_var.data[j];
25843 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
25844 ret_arr_ptr[j] = ret_conv_9_ref;
25847 FREE(ret_var.data);
25851 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_read"))) TS_C2Tuple_BlockHashChannelMonitorZ_read(int8_tArray ser, uint64_t arg_a, uint64_t arg_b) {
25852 LDKu8slice ser_ref;
25853 ser_ref.datalen = ser->arr_len;
25854 ser_ref.data = ser->elems;
25855 void* arg_a_ptr = untag_ptr(arg_a);
25856 if (ptr_is_owned(arg_a)) { CHECK_ACCESS(arg_a_ptr); }
25857 LDKEntropySource* arg_a_conv = (LDKEntropySource*)arg_a_ptr;
25858 void* arg_b_ptr = untag_ptr(arg_b);
25859 if (ptr_is_owned(arg_b)) { CHECK_ACCESS(arg_b_ptr); }
25860 LDKSignerProvider* arg_b_conv = (LDKSignerProvider*)arg_b_ptr;
25861 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
25862 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_a_conv, arg_b_conv);
25864 return tag_ptr(ret_conv, true);
25867 void __attribute__((export_name("TS_OutPoint_free"))) TS_OutPoint_free(uint64_t this_obj) {
25868 LDKOutPoint this_obj_conv;
25869 this_obj_conv.inner = untag_ptr(this_obj);
25870 this_obj_conv.is_owned = ptr_is_owned(this_obj);
25871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25872 OutPoint_free(this_obj_conv);
25875 int8_tArray __attribute__((export_name("TS_OutPoint_get_txid"))) TS_OutPoint_get_txid(uint64_t this_ptr) {
25876 LDKOutPoint this_ptr_conv;
25877 this_ptr_conv.inner = untag_ptr(this_ptr);
25878 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25879 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25880 this_ptr_conv.is_owned = false;
25881 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25882 memcpy(ret_arr->elems, *OutPoint_get_txid(&this_ptr_conv), 32);
25886 void __attribute__((export_name("TS_OutPoint_set_txid"))) TS_OutPoint_set_txid(uint64_t this_ptr, int8_tArray val) {
25887 LDKOutPoint this_ptr_conv;
25888 this_ptr_conv.inner = untag_ptr(this_ptr);
25889 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25891 this_ptr_conv.is_owned = false;
25892 LDKThirtyTwoBytes val_ref;
25893 CHECK(val->arr_len == 32);
25894 memcpy(val_ref.data, val->elems, 32); FREE(val);
25895 OutPoint_set_txid(&this_ptr_conv, val_ref);
25898 int16_t __attribute__((export_name("TS_OutPoint_get_index"))) TS_OutPoint_get_index(uint64_t this_ptr) {
25899 LDKOutPoint this_ptr_conv;
25900 this_ptr_conv.inner = untag_ptr(this_ptr);
25901 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25902 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25903 this_ptr_conv.is_owned = false;
25904 int16_t ret_conv = OutPoint_get_index(&this_ptr_conv);
25908 void __attribute__((export_name("TS_OutPoint_set_index"))) TS_OutPoint_set_index(uint64_t this_ptr, int16_t val) {
25909 LDKOutPoint this_ptr_conv;
25910 this_ptr_conv.inner = untag_ptr(this_ptr);
25911 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
25912 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25913 this_ptr_conv.is_owned = false;
25914 OutPoint_set_index(&this_ptr_conv, val);
25917 uint64_t __attribute__((export_name("TS_OutPoint_new"))) TS_OutPoint_new(int8_tArray txid_arg, int16_t index_arg) {
25918 LDKThirtyTwoBytes txid_arg_ref;
25919 CHECK(txid_arg->arr_len == 32);
25920 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
25921 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
25922 uint64_t ret_ref = 0;
25923 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25924 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25928 static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
25929 LDKOutPoint ret_var = OutPoint_clone(arg);
25930 uint64_t ret_ref = 0;
25931 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25932 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25935 int64_t __attribute__((export_name("TS_OutPoint_clone_ptr"))) TS_OutPoint_clone_ptr(uint64_t arg) {
25936 LDKOutPoint arg_conv;
25937 arg_conv.inner = untag_ptr(arg);
25938 arg_conv.is_owned = ptr_is_owned(arg);
25939 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25940 arg_conv.is_owned = false;
25941 int64_t ret_conv = OutPoint_clone_ptr(&arg_conv);
25945 uint64_t __attribute__((export_name("TS_OutPoint_clone"))) TS_OutPoint_clone(uint64_t orig) {
25946 LDKOutPoint orig_conv;
25947 orig_conv.inner = untag_ptr(orig);
25948 orig_conv.is_owned = ptr_is_owned(orig);
25949 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25950 orig_conv.is_owned = false;
25951 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
25952 uint64_t ret_ref = 0;
25953 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25954 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
25958 jboolean __attribute__((export_name("TS_OutPoint_eq"))) TS_OutPoint_eq(uint64_t a, uint64_t b) {
25959 LDKOutPoint a_conv;
25960 a_conv.inner = untag_ptr(a);
25961 a_conv.is_owned = ptr_is_owned(a);
25962 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25963 a_conv.is_owned = false;
25964 LDKOutPoint b_conv;
25965 b_conv.inner = untag_ptr(b);
25966 b_conv.is_owned = ptr_is_owned(b);
25967 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
25968 b_conv.is_owned = false;
25969 jboolean ret_conv = OutPoint_eq(&a_conv, &b_conv);
25973 int64_t __attribute__((export_name("TS_OutPoint_hash"))) TS_OutPoint_hash(uint64_t o) {
25974 LDKOutPoint o_conv;
25975 o_conv.inner = untag_ptr(o);
25976 o_conv.is_owned = ptr_is_owned(o);
25977 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25978 o_conv.is_owned = false;
25979 int64_t ret_conv = OutPoint_hash(&o_conv);
25983 int8_tArray __attribute__((export_name("TS_OutPoint_to_channel_id"))) TS_OutPoint_to_channel_id(uint64_t this_arg) {
25984 LDKOutPoint this_arg_conv;
25985 this_arg_conv.inner = untag_ptr(this_arg);
25986 this_arg_conv.is_owned = ptr_is_owned(this_arg);
25987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25988 this_arg_conv.is_owned = false;
25989 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25990 memcpy(ret_arr->elems, OutPoint_to_channel_id(&this_arg_conv).data, 32);
25994 int8_tArray __attribute__((export_name("TS_OutPoint_write"))) TS_OutPoint_write(uint64_t obj) {
25995 LDKOutPoint obj_conv;
25996 obj_conv.inner = untag_ptr(obj);
25997 obj_conv.is_owned = ptr_is_owned(obj);
25998 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25999 obj_conv.is_owned = false;
26000 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
26001 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26002 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26003 CVec_u8Z_free(ret_var);
26007 uint64_t __attribute__((export_name("TS_OutPoint_read"))) TS_OutPoint_read(int8_tArray ser) {
26008 LDKu8slice ser_ref;
26009 ser_ref.datalen = ser->arr_len;
26010 ser_ref.data = ser->elems;
26011 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
26012 *ret_conv = OutPoint_read(ser_ref);
26014 return tag_ptr(ret_conv, true);
26017 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_free"))) TS_DelayedPaymentOutputDescriptor_free(uint64_t this_obj) {
26018 LDKDelayedPaymentOutputDescriptor this_obj_conv;
26019 this_obj_conv.inner = untag_ptr(this_obj);
26020 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26021 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26022 DelayedPaymentOutputDescriptor_free(this_obj_conv);
26025 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_outpoint"))) TS_DelayedPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
26026 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26027 this_ptr_conv.inner = untag_ptr(this_ptr);
26028 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26030 this_ptr_conv.is_owned = false;
26031 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
26032 uint64_t ret_ref = 0;
26033 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26034 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26038 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_outpoint"))) TS_DelayedPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
26039 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26040 this_ptr_conv.inner = untag_ptr(this_ptr);
26041 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26042 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26043 this_ptr_conv.is_owned = false;
26044 LDKOutPoint val_conv;
26045 val_conv.inner = untag_ptr(val);
26046 val_conv.is_owned = ptr_is_owned(val);
26047 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26048 val_conv = OutPoint_clone(&val_conv);
26049 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
26052 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(uint64_t this_ptr) {
26053 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26054 this_ptr_conv.inner = untag_ptr(this_ptr);
26055 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26057 this_ptr_conv.is_owned = false;
26058 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
26059 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
26063 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
26064 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26065 this_ptr_conv.inner = untag_ptr(this_ptr);
26066 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26068 this_ptr_conv.is_owned = false;
26069 LDKPublicKey val_ref;
26070 CHECK(val->arr_len == 33);
26071 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
26072 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
26075 int16_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_get_to_self_delay(uint64_t this_ptr) {
26076 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26077 this_ptr_conv.inner = untag_ptr(this_ptr);
26078 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26080 this_ptr_conv.is_owned = false;
26081 int16_t ret_conv = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
26085 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_set_to_self_delay(uint64_t this_ptr, int16_t val) {
26086 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26087 this_ptr_conv.inner = untag_ptr(this_ptr);
26088 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26090 this_ptr_conv.is_owned = false;
26091 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
26094 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_output"))) TS_DelayedPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
26095 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26096 this_ptr_conv.inner = untag_ptr(this_ptr);
26097 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26098 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26099 this_ptr_conv.is_owned = false;
26100 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
26101 *ret_ref = DelayedPaymentOutputDescriptor_get_output(&this_ptr_conv);
26102 return tag_ptr(ret_ref, true);
26105 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_output"))) TS_DelayedPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
26106 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26107 this_ptr_conv.inner = untag_ptr(this_ptr);
26108 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26110 this_ptr_conv.is_owned = false;
26111 void* val_ptr = untag_ptr(val);
26112 CHECK_ACCESS(val_ptr);
26113 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
26114 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
26115 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
26118 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(uint64_t this_ptr) {
26119 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26120 this_ptr_conv.inner = untag_ptr(this_ptr);
26121 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26122 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26123 this_ptr_conv.is_owned = false;
26124 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
26125 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
26129 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(uint64_t this_ptr, int8_tArray val) {
26130 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26131 this_ptr_conv.inner = untag_ptr(this_ptr);
26132 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26134 this_ptr_conv.is_owned = false;
26135 LDKPublicKey val_ref;
26136 CHECK(val->arr_len == 33);
26137 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
26138 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
26141 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
26142 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26143 this_ptr_conv.inner = untag_ptr(this_ptr);
26144 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26146 this_ptr_conv.is_owned = false;
26147 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26148 memcpy(ret_arr->elems, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
26152 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
26153 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26154 this_ptr_conv.inner = untag_ptr(this_ptr);
26155 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26156 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26157 this_ptr_conv.is_owned = false;
26158 LDKThirtyTwoBytes val_ref;
26159 CHECK(val->arr_len == 32);
26160 memcpy(val_ref.data, val->elems, 32); FREE(val);
26161 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
26164 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
26165 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26166 this_ptr_conv.inner = untag_ptr(this_ptr);
26167 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26169 this_ptr_conv.is_owned = false;
26170 int64_t ret_conv = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
26174 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
26175 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
26176 this_ptr_conv.inner = untag_ptr(this_ptr);
26177 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26179 this_ptr_conv.is_owned = false;
26180 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
26183 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) {
26184 LDKOutPoint outpoint_arg_conv;
26185 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
26186 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
26187 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
26188 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
26189 LDKPublicKey per_commitment_point_arg_ref;
26190 CHECK(per_commitment_point_arg->arr_len == 33);
26191 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
26192 void* output_arg_ptr = untag_ptr(output_arg);
26193 CHECK_ACCESS(output_arg_ptr);
26194 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
26195 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
26196 LDKPublicKey revocation_pubkey_arg_ref;
26197 CHECK(revocation_pubkey_arg->arr_len == 33);
26198 memcpy(revocation_pubkey_arg_ref.compressed_form, revocation_pubkey_arg->elems, 33); FREE(revocation_pubkey_arg);
26199 LDKThirtyTwoBytes channel_keys_id_arg_ref;
26200 CHECK(channel_keys_id_arg->arr_len == 32);
26201 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
26202 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);
26203 uint64_t ret_ref = 0;
26204 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26205 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26209 static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
26210 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
26211 uint64_t ret_ref = 0;
26212 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26213 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26216 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone_ptr"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
26217 LDKDelayedPaymentOutputDescriptor arg_conv;
26218 arg_conv.inner = untag_ptr(arg);
26219 arg_conv.is_owned = ptr_is_owned(arg);
26220 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26221 arg_conv.is_owned = false;
26222 int64_t ret_conv = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
26226 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone"))) TS_DelayedPaymentOutputDescriptor_clone(uint64_t orig) {
26227 LDKDelayedPaymentOutputDescriptor orig_conv;
26228 orig_conv.inner = untag_ptr(orig);
26229 orig_conv.is_owned = ptr_is_owned(orig);
26230 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26231 orig_conv.is_owned = false;
26232 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
26233 uint64_t ret_ref = 0;
26234 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26235 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26239 jboolean __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_eq"))) TS_DelayedPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
26240 LDKDelayedPaymentOutputDescriptor a_conv;
26241 a_conv.inner = untag_ptr(a);
26242 a_conv.is_owned = ptr_is_owned(a);
26243 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26244 a_conv.is_owned = false;
26245 LDKDelayedPaymentOutputDescriptor b_conv;
26246 b_conv.inner = untag_ptr(b);
26247 b_conv.is_owned = ptr_is_owned(b);
26248 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
26249 b_conv.is_owned = false;
26250 jboolean ret_conv = DelayedPaymentOutputDescriptor_eq(&a_conv, &b_conv);
26254 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_write"))) TS_DelayedPaymentOutputDescriptor_write(uint64_t obj) {
26255 LDKDelayedPaymentOutputDescriptor obj_conv;
26256 obj_conv.inner = untag_ptr(obj);
26257 obj_conv.is_owned = ptr_is_owned(obj);
26258 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26259 obj_conv.is_owned = false;
26260 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
26261 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26262 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26263 CVec_u8Z_free(ret_var);
26267 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_read"))) TS_DelayedPaymentOutputDescriptor_read(int8_tArray ser) {
26268 LDKu8slice ser_ref;
26269 ser_ref.datalen = ser->arr_len;
26270 ser_ref.data = ser->elems;
26271 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
26272 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
26274 return tag_ptr(ret_conv, true);
26277 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_free"))) TS_StaticPaymentOutputDescriptor_free(uint64_t this_obj) {
26278 LDKStaticPaymentOutputDescriptor this_obj_conv;
26279 this_obj_conv.inner = untag_ptr(this_obj);
26280 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26282 StaticPaymentOutputDescriptor_free(this_obj_conv);
26285 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_outpoint"))) TS_StaticPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
26286 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26287 this_ptr_conv.inner = untag_ptr(this_ptr);
26288 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26290 this_ptr_conv.is_owned = false;
26291 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
26292 uint64_t ret_ref = 0;
26293 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26294 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26298 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_outpoint"))) TS_StaticPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
26299 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26300 this_ptr_conv.inner = untag_ptr(this_ptr);
26301 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26303 this_ptr_conv.is_owned = false;
26304 LDKOutPoint val_conv;
26305 val_conv.inner = untag_ptr(val);
26306 val_conv.is_owned = ptr_is_owned(val);
26307 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26308 val_conv = OutPoint_clone(&val_conv);
26309 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
26312 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_output"))) TS_StaticPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
26313 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26314 this_ptr_conv.inner = untag_ptr(this_ptr);
26315 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26317 this_ptr_conv.is_owned = false;
26318 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
26319 *ret_ref = StaticPaymentOutputDescriptor_get_output(&this_ptr_conv);
26320 return tag_ptr(ret_ref, true);
26323 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_output"))) TS_StaticPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
26324 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26325 this_ptr_conv.inner = untag_ptr(this_ptr);
26326 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26327 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26328 this_ptr_conv.is_owned = false;
26329 void* val_ptr = untag_ptr(val);
26330 CHECK_ACCESS(val_ptr);
26331 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
26332 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
26333 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
26336 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
26337 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26338 this_ptr_conv.inner = untag_ptr(this_ptr);
26339 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26341 this_ptr_conv.is_owned = false;
26342 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26343 memcpy(ret_arr->elems, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
26347 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
26348 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26349 this_ptr_conv.inner = untag_ptr(this_ptr);
26350 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26352 this_ptr_conv.is_owned = false;
26353 LDKThirtyTwoBytes val_ref;
26354 CHECK(val->arr_len == 32);
26355 memcpy(val_ref.data, val->elems, 32); FREE(val);
26356 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
26359 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
26360 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26361 this_ptr_conv.inner = untag_ptr(this_ptr);
26362 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26364 this_ptr_conv.is_owned = false;
26365 int64_t ret_conv = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
26369 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
26370 LDKStaticPaymentOutputDescriptor this_ptr_conv;
26371 this_ptr_conv.inner = untag_ptr(this_ptr);
26372 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26374 this_ptr_conv.is_owned = false;
26375 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
26378 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) {
26379 LDKOutPoint outpoint_arg_conv;
26380 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
26381 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
26382 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
26383 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
26384 void* output_arg_ptr = untag_ptr(output_arg);
26385 CHECK_ACCESS(output_arg_ptr);
26386 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
26387 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
26388 LDKThirtyTwoBytes channel_keys_id_arg_ref;
26389 CHECK(channel_keys_id_arg->arr_len == 32);
26390 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
26391 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
26392 uint64_t ret_ref = 0;
26393 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26394 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26398 static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
26399 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
26400 uint64_t ret_ref = 0;
26401 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26402 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26405 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone_ptr"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
26406 LDKStaticPaymentOutputDescriptor arg_conv;
26407 arg_conv.inner = untag_ptr(arg);
26408 arg_conv.is_owned = ptr_is_owned(arg);
26409 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26410 arg_conv.is_owned = false;
26411 int64_t ret_conv = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
26415 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone"))) TS_StaticPaymentOutputDescriptor_clone(uint64_t orig) {
26416 LDKStaticPaymentOutputDescriptor orig_conv;
26417 orig_conv.inner = untag_ptr(orig);
26418 orig_conv.is_owned = ptr_is_owned(orig);
26419 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26420 orig_conv.is_owned = false;
26421 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
26422 uint64_t ret_ref = 0;
26423 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26424 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26428 jboolean __attribute__((export_name("TS_StaticPaymentOutputDescriptor_eq"))) TS_StaticPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
26429 LDKStaticPaymentOutputDescriptor a_conv;
26430 a_conv.inner = untag_ptr(a);
26431 a_conv.is_owned = ptr_is_owned(a);
26432 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26433 a_conv.is_owned = false;
26434 LDKStaticPaymentOutputDescriptor b_conv;
26435 b_conv.inner = untag_ptr(b);
26436 b_conv.is_owned = ptr_is_owned(b);
26437 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
26438 b_conv.is_owned = false;
26439 jboolean ret_conv = StaticPaymentOutputDescriptor_eq(&a_conv, &b_conv);
26443 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_write"))) TS_StaticPaymentOutputDescriptor_write(uint64_t obj) {
26444 LDKStaticPaymentOutputDescriptor obj_conv;
26445 obj_conv.inner = untag_ptr(obj);
26446 obj_conv.is_owned = ptr_is_owned(obj);
26447 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
26448 obj_conv.is_owned = false;
26449 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
26450 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26451 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26452 CVec_u8Z_free(ret_var);
26456 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_read"))) TS_StaticPaymentOutputDescriptor_read(int8_tArray ser) {
26457 LDKu8slice ser_ref;
26458 ser_ref.datalen = ser->arr_len;
26459 ser_ref.data = ser->elems;
26460 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
26461 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
26463 return tag_ptr(ret_conv, true);
26466 void __attribute__((export_name("TS_SpendableOutputDescriptor_free"))) TS_SpendableOutputDescriptor_free(uint64_t this_ptr) {
26467 if (!ptr_is_owned(this_ptr)) return;
26468 void* this_ptr_ptr = untag_ptr(this_ptr);
26469 CHECK_ACCESS(this_ptr_ptr);
26470 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(this_ptr_ptr);
26471 FREE(untag_ptr(this_ptr));
26472 SpendableOutputDescriptor_free(this_ptr_conv);
26475 static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
26476 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26477 *ret_copy = SpendableOutputDescriptor_clone(arg);
26478 uint64_t ret_ref = tag_ptr(ret_copy, true);
26481 int64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone_ptr"))) TS_SpendableOutputDescriptor_clone_ptr(uint64_t arg) {
26482 LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)untag_ptr(arg);
26483 int64_t ret_conv = SpendableOutputDescriptor_clone_ptr(arg_conv);
26487 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone"))) TS_SpendableOutputDescriptor_clone(uint64_t orig) {
26488 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)untag_ptr(orig);
26489 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26490 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
26491 uint64_t ret_ref = tag_ptr(ret_copy, true);
26495 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_output"))) TS_SpendableOutputDescriptor_static_output(uint64_t outpoint, uint64_t output) {
26496 LDKOutPoint outpoint_conv;
26497 outpoint_conv.inner = untag_ptr(outpoint);
26498 outpoint_conv.is_owned = ptr_is_owned(outpoint);
26499 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
26500 outpoint_conv = OutPoint_clone(&outpoint_conv);
26501 void* output_ptr = untag_ptr(output);
26502 CHECK_ACCESS(output_ptr);
26503 LDKTxOut output_conv = *(LDKTxOut*)(output_ptr);
26504 output_conv = TxOut_clone((LDKTxOut*)untag_ptr(output));
26505 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26506 *ret_copy = SpendableOutputDescriptor_static_output(outpoint_conv, output_conv);
26507 uint64_t ret_ref = tag_ptr(ret_copy, true);
26511 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_delayed_payment_output"))) TS_SpendableOutputDescriptor_delayed_payment_output(uint64_t a) {
26512 LDKDelayedPaymentOutputDescriptor a_conv;
26513 a_conv.inner = untag_ptr(a);
26514 a_conv.is_owned = ptr_is_owned(a);
26515 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26516 a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
26517 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26518 *ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
26519 uint64_t ret_ref = tag_ptr(ret_copy, true);
26523 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_payment_output"))) TS_SpendableOutputDescriptor_static_payment_output(uint64_t a) {
26524 LDKStaticPaymentOutputDescriptor a_conv;
26525 a_conv.inner = untag_ptr(a);
26526 a_conv.is_owned = ptr_is_owned(a);
26527 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
26528 a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
26529 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
26530 *ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
26531 uint64_t ret_ref = tag_ptr(ret_copy, true);
26535 jboolean __attribute__((export_name("TS_SpendableOutputDescriptor_eq"))) TS_SpendableOutputDescriptor_eq(uint64_t a, uint64_t b) {
26536 LDKSpendableOutputDescriptor* a_conv = (LDKSpendableOutputDescriptor*)untag_ptr(a);
26537 LDKSpendableOutputDescriptor* b_conv = (LDKSpendableOutputDescriptor*)untag_ptr(b);
26538 jboolean ret_conv = SpendableOutputDescriptor_eq(a_conv, b_conv);
26542 int8_tArray __attribute__((export_name("TS_SpendableOutputDescriptor_write"))) TS_SpendableOutputDescriptor_write(uint64_t obj) {
26543 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)untag_ptr(obj);
26544 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
26545 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
26546 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
26547 CVec_u8Z_free(ret_var);
26551 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_read"))) TS_SpendableOutputDescriptor_read(int8_tArray ser) {
26552 LDKu8slice ser_ref;
26553 ser_ref.datalen = ser->arr_len;
26554 ser_ref.data = ser->elems;
26555 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
26556 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
26558 return tag_ptr(ret_conv, true);
26561 void __attribute__((export_name("TS_ChannelSigner_free"))) TS_ChannelSigner_free(uint64_t this_ptr) {
26562 if (!ptr_is_owned(this_ptr)) return;
26563 void* this_ptr_ptr = untag_ptr(this_ptr);
26564 CHECK_ACCESS(this_ptr_ptr);
26565 LDKChannelSigner this_ptr_conv = *(LDKChannelSigner*)(this_ptr_ptr);
26566 FREE(untag_ptr(this_ptr));
26567 ChannelSigner_free(this_ptr_conv);
26570 void __attribute__((export_name("TS_EcdsaChannelSigner_free"))) TS_EcdsaChannelSigner_free(uint64_t this_ptr) {
26571 if (!ptr_is_owned(this_ptr)) return;
26572 void* this_ptr_ptr = untag_ptr(this_ptr);
26573 CHECK_ACCESS(this_ptr_ptr);
26574 LDKEcdsaChannelSigner this_ptr_conv = *(LDKEcdsaChannelSigner*)(this_ptr_ptr);
26575 FREE(untag_ptr(this_ptr));
26576 EcdsaChannelSigner_free(this_ptr_conv);
26579 static inline uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg) {
26580 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
26581 *ret_ret = WriteableEcdsaChannelSigner_clone(arg);
26582 return tag_ptr(ret_ret, true);
26584 int64_t __attribute__((export_name("TS_WriteableEcdsaChannelSigner_clone_ptr"))) TS_WriteableEcdsaChannelSigner_clone_ptr(uint64_t arg) {
26585 void* arg_ptr = untag_ptr(arg);
26586 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
26587 LDKWriteableEcdsaChannelSigner* arg_conv = (LDKWriteableEcdsaChannelSigner*)arg_ptr;
26588 int64_t ret_conv = WriteableEcdsaChannelSigner_clone_ptr(arg_conv);
26592 uint64_t __attribute__((export_name("TS_WriteableEcdsaChannelSigner_clone"))) TS_WriteableEcdsaChannelSigner_clone(uint64_t orig) {
26593 void* orig_ptr = untag_ptr(orig);
26594 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
26595 LDKWriteableEcdsaChannelSigner* orig_conv = (LDKWriteableEcdsaChannelSigner*)orig_ptr;
26596 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
26597 *ret_ret = WriteableEcdsaChannelSigner_clone(orig_conv);
26598 return tag_ptr(ret_ret, true);
26601 void __attribute__((export_name("TS_WriteableEcdsaChannelSigner_free"))) TS_WriteableEcdsaChannelSigner_free(uint64_t this_ptr) {
26602 if (!ptr_is_owned(this_ptr)) return;
26603 void* this_ptr_ptr = untag_ptr(this_ptr);
26604 CHECK_ACCESS(this_ptr_ptr);
26605 LDKWriteableEcdsaChannelSigner this_ptr_conv = *(LDKWriteableEcdsaChannelSigner*)(this_ptr_ptr);
26606 FREE(untag_ptr(this_ptr));
26607 WriteableEcdsaChannelSigner_free(this_ptr_conv);
26610 uint32_t __attribute__((export_name("TS_Recipient_clone"))) TS_Recipient_clone(uint64_t orig) {
26611 LDKRecipient* orig_conv = (LDKRecipient*)untag_ptr(orig);
26612 uint32_t ret_conv = LDKRecipient_to_js(Recipient_clone(orig_conv));
26616 uint32_t __attribute__((export_name("TS_Recipient_node"))) TS_Recipient_node() {
26617 uint32_t ret_conv = LDKRecipient_to_js(Recipient_node());
26621 uint32_t __attribute__((export_name("TS_Recipient_phantom_node"))) TS_Recipient_phantom_node() {
26622 uint32_t ret_conv = LDKRecipient_to_js(Recipient_phantom_node());
26626 void __attribute__((export_name("TS_EntropySource_free"))) TS_EntropySource_free(uint64_t this_ptr) {
26627 if (!ptr_is_owned(this_ptr)) return;
26628 void* this_ptr_ptr = untag_ptr(this_ptr);
26629 CHECK_ACCESS(this_ptr_ptr);
26630 LDKEntropySource this_ptr_conv = *(LDKEntropySource*)(this_ptr_ptr);
26631 FREE(untag_ptr(this_ptr));
26632 EntropySource_free(this_ptr_conv);
26635 void __attribute__((export_name("TS_NodeSigner_free"))) TS_NodeSigner_free(uint64_t this_ptr) {
26636 if (!ptr_is_owned(this_ptr)) return;
26637 void* this_ptr_ptr = untag_ptr(this_ptr);
26638 CHECK_ACCESS(this_ptr_ptr);
26639 LDKNodeSigner this_ptr_conv = *(LDKNodeSigner*)(this_ptr_ptr);
26640 FREE(untag_ptr(this_ptr));
26641 NodeSigner_free(this_ptr_conv);
26644 void __attribute__((export_name("TS_SignerProvider_free"))) TS_SignerProvider_free(uint64_t this_ptr) {
26645 if (!ptr_is_owned(this_ptr)) return;
26646 void* this_ptr_ptr = untag_ptr(this_ptr);
26647 CHECK_ACCESS(this_ptr_ptr);
26648 LDKSignerProvider this_ptr_conv = *(LDKSignerProvider*)(this_ptr_ptr);
26649 FREE(untag_ptr(this_ptr));
26650 SignerProvider_free(this_ptr_conv);
26653 void __attribute__((export_name("TS_InMemorySigner_free"))) TS_InMemorySigner_free(uint64_t this_obj) {
26654 LDKInMemorySigner this_obj_conv;
26655 this_obj_conv.inner = untag_ptr(this_obj);
26656 this_obj_conv.is_owned = ptr_is_owned(this_obj);
26657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26658 InMemorySigner_free(this_obj_conv);
26661 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_funding_key"))) TS_InMemorySigner_get_funding_key(uint64_t this_ptr) {
26662 LDKInMemorySigner this_ptr_conv;
26663 this_ptr_conv.inner = untag_ptr(this_ptr);
26664 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26666 this_ptr_conv.is_owned = false;
26667 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26668 memcpy(ret_arr->elems, *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
26672 void __attribute__((export_name("TS_InMemorySigner_set_funding_key"))) TS_InMemorySigner_set_funding_key(uint64_t this_ptr, int8_tArray val) {
26673 LDKInMemorySigner this_ptr_conv;
26674 this_ptr_conv.inner = untag_ptr(this_ptr);
26675 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26677 this_ptr_conv.is_owned = false;
26678 LDKSecretKey val_ref;
26679 CHECK(val->arr_len == 32);
26680 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26681 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
26684 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_revocation_base_key"))) TS_InMemorySigner_get_revocation_base_key(uint64_t this_ptr) {
26685 LDKInMemorySigner this_ptr_conv;
26686 this_ptr_conv.inner = untag_ptr(this_ptr);
26687 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26689 this_ptr_conv.is_owned = false;
26690 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26691 memcpy(ret_arr->elems, *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
26695 void __attribute__((export_name("TS_InMemorySigner_set_revocation_base_key"))) TS_InMemorySigner_set_revocation_base_key(uint64_t this_ptr, int8_tArray val) {
26696 LDKInMemorySigner this_ptr_conv;
26697 this_ptr_conv.inner = untag_ptr(this_ptr);
26698 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26700 this_ptr_conv.is_owned = false;
26701 LDKSecretKey val_ref;
26702 CHECK(val->arr_len == 32);
26703 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26704 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
26707 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_payment_key"))) TS_InMemorySigner_get_payment_key(uint64_t this_ptr) {
26708 LDKInMemorySigner this_ptr_conv;
26709 this_ptr_conv.inner = untag_ptr(this_ptr);
26710 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26712 this_ptr_conv.is_owned = false;
26713 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26714 memcpy(ret_arr->elems, *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
26718 void __attribute__((export_name("TS_InMemorySigner_set_payment_key"))) TS_InMemorySigner_set_payment_key(uint64_t this_ptr, int8_tArray val) {
26719 LDKInMemorySigner this_ptr_conv;
26720 this_ptr_conv.inner = untag_ptr(this_ptr);
26721 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26723 this_ptr_conv.is_owned = false;
26724 LDKSecretKey val_ref;
26725 CHECK(val->arr_len == 32);
26726 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26727 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
26730 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_delayed_payment_base_key"))) TS_InMemorySigner_get_delayed_payment_base_key(uint64_t this_ptr) {
26731 LDKInMemorySigner this_ptr_conv;
26732 this_ptr_conv.inner = untag_ptr(this_ptr);
26733 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26735 this_ptr_conv.is_owned = false;
26736 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26737 memcpy(ret_arr->elems, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
26741 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) {
26742 LDKInMemorySigner this_ptr_conv;
26743 this_ptr_conv.inner = untag_ptr(this_ptr);
26744 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26745 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26746 this_ptr_conv.is_owned = false;
26747 LDKSecretKey val_ref;
26748 CHECK(val->arr_len == 32);
26749 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26750 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
26753 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_htlc_base_key"))) TS_InMemorySigner_get_htlc_base_key(uint64_t this_ptr) {
26754 LDKInMemorySigner this_ptr_conv;
26755 this_ptr_conv.inner = untag_ptr(this_ptr);
26756 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26757 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26758 this_ptr_conv.is_owned = false;
26759 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26760 memcpy(ret_arr->elems, *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
26764 void __attribute__((export_name("TS_InMemorySigner_set_htlc_base_key"))) TS_InMemorySigner_set_htlc_base_key(uint64_t this_ptr, int8_tArray val) {
26765 LDKInMemorySigner this_ptr_conv;
26766 this_ptr_conv.inner = untag_ptr(this_ptr);
26767 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26768 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26769 this_ptr_conv.is_owned = false;
26770 LDKSecretKey val_ref;
26771 CHECK(val->arr_len == 32);
26772 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
26773 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
26776 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_commitment_seed"))) TS_InMemorySigner_get_commitment_seed(uint64_t this_ptr) {
26777 LDKInMemorySigner this_ptr_conv;
26778 this_ptr_conv.inner = untag_ptr(this_ptr);
26779 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26781 this_ptr_conv.is_owned = false;
26782 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26783 memcpy(ret_arr->elems, *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
26787 void __attribute__((export_name("TS_InMemorySigner_set_commitment_seed"))) TS_InMemorySigner_set_commitment_seed(uint64_t this_ptr, int8_tArray val) {
26788 LDKInMemorySigner this_ptr_conv;
26789 this_ptr_conv.inner = untag_ptr(this_ptr);
26790 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
26791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26792 this_ptr_conv.is_owned = false;
26793 LDKThirtyTwoBytes val_ref;
26794 CHECK(val->arr_len == 32);
26795 memcpy(val_ref.data, val->elems, 32); FREE(val);
26796 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
26799 static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
26800 LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
26801 uint64_t ret_ref = 0;
26802 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26803 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26806 int64_t __attribute__((export_name("TS_InMemorySigner_clone_ptr"))) TS_InMemorySigner_clone_ptr(uint64_t arg) {
26807 LDKInMemorySigner arg_conv;
26808 arg_conv.inner = untag_ptr(arg);
26809 arg_conv.is_owned = ptr_is_owned(arg);
26810 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26811 arg_conv.is_owned = false;
26812 int64_t ret_conv = InMemorySigner_clone_ptr(&arg_conv);
26816 uint64_t __attribute__((export_name("TS_InMemorySigner_clone"))) TS_InMemorySigner_clone(uint64_t orig) {
26817 LDKInMemorySigner orig_conv;
26818 orig_conv.inner = untag_ptr(orig);
26819 orig_conv.is_owned = ptr_is_owned(orig);
26820 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26821 orig_conv.is_owned = false;
26822 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
26823 uint64_t ret_ref = 0;
26824 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26825 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26829 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) {
26830 LDKSecretKey funding_key_ref;
26831 CHECK(funding_key->arr_len == 32);
26832 memcpy(funding_key_ref.bytes, funding_key->elems, 32); FREE(funding_key);
26833 LDKSecretKey revocation_base_key_ref;
26834 CHECK(revocation_base_key->arr_len == 32);
26835 memcpy(revocation_base_key_ref.bytes, revocation_base_key->elems, 32); FREE(revocation_base_key);
26836 LDKSecretKey payment_key_ref;
26837 CHECK(payment_key->arr_len == 32);
26838 memcpy(payment_key_ref.bytes, payment_key->elems, 32); FREE(payment_key);
26839 LDKSecretKey delayed_payment_base_key_ref;
26840 CHECK(delayed_payment_base_key->arr_len == 32);
26841 memcpy(delayed_payment_base_key_ref.bytes, delayed_payment_base_key->elems, 32); FREE(delayed_payment_base_key);
26842 LDKSecretKey htlc_base_key_ref;
26843 CHECK(htlc_base_key->arr_len == 32);
26844 memcpy(htlc_base_key_ref.bytes, htlc_base_key->elems, 32); FREE(htlc_base_key);
26845 LDKThirtyTwoBytes commitment_seed_ref;
26846 CHECK(commitment_seed->arr_len == 32);
26847 memcpy(commitment_seed_ref.data, commitment_seed->elems, 32); FREE(commitment_seed);
26848 LDKThirtyTwoBytes channel_keys_id_ref;
26849 CHECK(channel_keys_id->arr_len == 32);
26850 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
26851 LDKThirtyTwoBytes rand_bytes_unique_start_ref;
26852 CHECK(rand_bytes_unique_start->arr_len == 32);
26853 memcpy(rand_bytes_unique_start_ref.data, rand_bytes_unique_start->elems, 32); FREE(rand_bytes_unique_start);
26854 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);
26855 uint64_t ret_ref = 0;
26856 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26857 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26861 uint64_t __attribute__((export_name("TS_InMemorySigner_counterparty_pubkeys"))) TS_InMemorySigner_counterparty_pubkeys(uint64_t this_arg) {
26862 LDKInMemorySigner this_arg_conv;
26863 this_arg_conv.inner = untag_ptr(this_arg);
26864 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26866 this_arg_conv.is_owned = false;
26867 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
26868 uint64_t ret_ref = 0;
26869 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26870 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26874 int16_t __attribute__((export_name("TS_InMemorySigner_counterparty_selected_contest_delay"))) TS_InMemorySigner_counterparty_selected_contest_delay(uint64_t this_arg) {
26875 LDKInMemorySigner this_arg_conv;
26876 this_arg_conv.inner = untag_ptr(this_arg);
26877 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26879 this_arg_conv.is_owned = false;
26880 int16_t ret_conv = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
26884 int16_t __attribute__((export_name("TS_InMemorySigner_holder_selected_contest_delay"))) TS_InMemorySigner_holder_selected_contest_delay(uint64_t this_arg) {
26885 LDKInMemorySigner this_arg_conv;
26886 this_arg_conv.inner = untag_ptr(this_arg);
26887 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26888 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26889 this_arg_conv.is_owned = false;
26890 int16_t ret_conv = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
26894 jboolean __attribute__((export_name("TS_InMemorySigner_is_outbound"))) TS_InMemorySigner_is_outbound(uint64_t this_arg) {
26895 LDKInMemorySigner this_arg_conv;
26896 this_arg_conv.inner = untag_ptr(this_arg);
26897 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26899 this_arg_conv.is_owned = false;
26900 jboolean ret_conv = InMemorySigner_is_outbound(&this_arg_conv);
26904 uint64_t __attribute__((export_name("TS_InMemorySigner_funding_outpoint"))) TS_InMemorySigner_funding_outpoint(uint64_t this_arg) {
26905 LDKInMemorySigner this_arg_conv;
26906 this_arg_conv.inner = untag_ptr(this_arg);
26907 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26908 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26909 this_arg_conv.is_owned = false;
26910 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
26911 uint64_t ret_ref = 0;
26912 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26913 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26917 uint64_t __attribute__((export_name("TS_InMemorySigner_get_channel_parameters"))) TS_InMemorySigner_get_channel_parameters(uint64_t this_arg) {
26918 LDKInMemorySigner this_arg_conv;
26919 this_arg_conv.inner = untag_ptr(this_arg);
26920 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26921 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26922 this_arg_conv.is_owned = false;
26923 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
26924 uint64_t ret_ref = 0;
26925 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26926 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
26930 jboolean __attribute__((export_name("TS_InMemorySigner_opt_anchors"))) TS_InMemorySigner_opt_anchors(uint64_t this_arg) {
26931 LDKInMemorySigner this_arg_conv;
26932 this_arg_conv.inner = untag_ptr(this_arg);
26933 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26935 this_arg_conv.is_owned = false;
26936 jboolean ret_conv = InMemorySigner_opt_anchors(&this_arg_conv);
26940 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) {
26941 LDKInMemorySigner this_arg_conv;
26942 this_arg_conv.inner = untag_ptr(this_arg);
26943 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26945 this_arg_conv.is_owned = false;
26946 LDKTransaction spend_tx_ref;
26947 spend_tx_ref.datalen = spend_tx->arr_len;
26948 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
26949 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
26950 spend_tx_ref.data_is_owned = true;
26951 LDKStaticPaymentOutputDescriptor descriptor_conv;
26952 descriptor_conv.inner = untag_ptr(descriptor);
26953 descriptor_conv.is_owned = ptr_is_owned(descriptor);
26954 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
26955 descriptor_conv.is_owned = false;
26956 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
26957 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
26958 return tag_ptr(ret_conv, true);
26961 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) {
26962 LDKInMemorySigner this_arg_conv;
26963 this_arg_conv.inner = untag_ptr(this_arg);
26964 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26966 this_arg_conv.is_owned = false;
26967 LDKTransaction spend_tx_ref;
26968 spend_tx_ref.datalen = spend_tx->arr_len;
26969 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
26970 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
26971 spend_tx_ref.data_is_owned = true;
26972 LDKDelayedPaymentOutputDescriptor descriptor_conv;
26973 descriptor_conv.inner = untag_ptr(descriptor);
26974 descriptor_conv.is_owned = ptr_is_owned(descriptor);
26975 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
26976 descriptor_conv.is_owned = false;
26977 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
26978 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
26979 return tag_ptr(ret_conv, true);
26982 uint64_t __attribute__((export_name("TS_InMemorySigner_as_EntropySource"))) TS_InMemorySigner_as_EntropySource(uint64_t this_arg) {
26983 LDKInMemorySigner this_arg_conv;
26984 this_arg_conv.inner = untag_ptr(this_arg);
26985 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26986 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26987 this_arg_conv.is_owned = false;
26988 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
26989 *ret_ret = InMemorySigner_as_EntropySource(&this_arg_conv);
26990 return tag_ptr(ret_ret, true);
26993 uint64_t __attribute__((export_name("TS_InMemorySigner_as_ChannelSigner"))) TS_InMemorySigner_as_ChannelSigner(uint64_t this_arg) {
26994 LDKInMemorySigner this_arg_conv;
26995 this_arg_conv.inner = untag_ptr(this_arg);
26996 this_arg_conv.is_owned = ptr_is_owned(this_arg);
26997 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26998 this_arg_conv.is_owned = false;
26999 LDKChannelSigner* ret_ret = MALLOC(sizeof(LDKChannelSigner), "LDKChannelSigner");
27000 *ret_ret = InMemorySigner_as_ChannelSigner(&this_arg_conv);
27001 return tag_ptr(ret_ret, true);
27004 uint64_t __attribute__((export_name("TS_InMemorySigner_as_EcdsaChannelSigner"))) TS_InMemorySigner_as_EcdsaChannelSigner(uint64_t this_arg) {
27005 LDKInMemorySigner this_arg_conv;
27006 this_arg_conv.inner = untag_ptr(this_arg);
27007 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27009 this_arg_conv.is_owned = false;
27010 LDKEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKEcdsaChannelSigner), "LDKEcdsaChannelSigner");
27011 *ret_ret = InMemorySigner_as_EcdsaChannelSigner(&this_arg_conv);
27012 return tag_ptr(ret_ret, true);
27015 uint64_t __attribute__((export_name("TS_InMemorySigner_as_WriteableEcdsaChannelSigner"))) TS_InMemorySigner_as_WriteableEcdsaChannelSigner(uint64_t this_arg) {
27016 LDKInMemorySigner this_arg_conv;
27017 this_arg_conv.inner = untag_ptr(this_arg);
27018 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27020 this_arg_conv.is_owned = false;
27021 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
27022 *ret_ret = InMemorySigner_as_WriteableEcdsaChannelSigner(&this_arg_conv);
27023 return tag_ptr(ret_ret, true);
27026 int8_tArray __attribute__((export_name("TS_InMemorySigner_write"))) TS_InMemorySigner_write(uint64_t obj) {
27027 LDKInMemorySigner obj_conv;
27028 obj_conv.inner = untag_ptr(obj);
27029 obj_conv.is_owned = ptr_is_owned(obj);
27030 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27031 obj_conv.is_owned = false;
27032 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
27033 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27034 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27035 CVec_u8Z_free(ret_var);
27039 uint64_t __attribute__((export_name("TS_InMemorySigner_read"))) TS_InMemorySigner_read(int8_tArray ser, uint64_t arg) {
27040 LDKu8slice ser_ref;
27041 ser_ref.datalen = ser->arr_len;
27042 ser_ref.data = ser->elems;
27043 void* arg_ptr = untag_ptr(arg);
27044 CHECK_ACCESS(arg_ptr);
27045 LDKEntropySource arg_conv = *(LDKEntropySource*)(arg_ptr);
27046 if (arg_conv.free == LDKEntropySource_JCalls_free) {
27047 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27048 LDKEntropySource_JCalls_cloned(&arg_conv);
27050 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
27051 *ret_conv = InMemorySigner_read(ser_ref, arg_conv);
27053 return tag_ptr(ret_conv, true);
27056 void __attribute__((export_name("TS_KeysManager_free"))) TS_KeysManager_free(uint64_t this_obj) {
27057 LDKKeysManager this_obj_conv;
27058 this_obj_conv.inner = untag_ptr(this_obj);
27059 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27060 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27061 KeysManager_free(this_obj_conv);
27064 uint64_t __attribute__((export_name("TS_KeysManager_new"))) TS_KeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
27065 uint8_t seed_arr[32];
27066 CHECK(seed->arr_len == 32);
27067 memcpy(seed_arr, seed->elems, 32); FREE(seed);
27068 uint8_t (*seed_ref)[32] = &seed_arr;
27069 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
27070 uint64_t ret_ref = 0;
27071 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27072 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27076 int8_tArray __attribute__((export_name("TS_KeysManager_get_node_secret_key"))) TS_KeysManager_get_node_secret_key(uint64_t this_arg) {
27077 LDKKeysManager this_arg_conv;
27078 this_arg_conv.inner = untag_ptr(this_arg);
27079 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27080 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27081 this_arg_conv.is_owned = false;
27082 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27083 memcpy(ret_arr->elems, KeysManager_get_node_secret_key(&this_arg_conv).bytes, 32);
27087 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) {
27088 LDKKeysManager this_arg_conv;
27089 this_arg_conv.inner = untag_ptr(this_arg);
27090 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27091 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27092 this_arg_conv.is_owned = false;
27093 uint8_t params_arr[32];
27094 CHECK(params->arr_len == 32);
27095 memcpy(params_arr, params->elems, 32); FREE(params);
27096 uint8_t (*params_ref)[32] = ¶ms_arr;
27097 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
27098 uint64_t ret_ref = 0;
27099 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27100 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27104 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) {
27105 LDKKeysManager this_arg_conv;
27106 this_arg_conv.inner = untag_ptr(this_arg);
27107 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27109 this_arg_conv.is_owned = false;
27110 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
27111 descriptors_constr.datalen = descriptors->arr_len;
27112 if (descriptors_constr.datalen > 0)
27113 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
27115 descriptors_constr.data = NULL;
27116 uint64_t* descriptors_vals = descriptors->elems;
27117 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
27118 uint64_t descriptors_conv_27 = descriptors_vals[b];
27119 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
27120 CHECK_ACCESS(descriptors_conv_27_ptr);
27121 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
27122 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
27123 descriptors_constr.data[b] = descriptors_conv_27_conv;
27126 LDKCVec_TxOutZ outputs_constr;
27127 outputs_constr.datalen = outputs->arr_len;
27128 if (outputs_constr.datalen > 0)
27129 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
27131 outputs_constr.data = NULL;
27132 uint64_t* outputs_vals = outputs->elems;
27133 for (size_t h = 0; h < outputs_constr.datalen; h++) {
27134 uint64_t outputs_conv_7 = outputs_vals[h];
27135 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
27136 CHECK_ACCESS(outputs_conv_7_ptr);
27137 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
27138 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
27139 outputs_constr.data[h] = outputs_conv_7_conv;
27142 LDKCVec_u8Z change_destination_script_ref;
27143 change_destination_script_ref.datalen = change_destination_script->arr_len;
27144 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
27145 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
27146 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
27147 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
27148 return tag_ptr(ret_conv, true);
27151 uint64_t __attribute__((export_name("TS_KeysManager_as_EntropySource"))) TS_KeysManager_as_EntropySource(uint64_t this_arg) {
27152 LDKKeysManager this_arg_conv;
27153 this_arg_conv.inner = untag_ptr(this_arg);
27154 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27156 this_arg_conv.is_owned = false;
27157 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
27158 *ret_ret = KeysManager_as_EntropySource(&this_arg_conv);
27159 return tag_ptr(ret_ret, true);
27162 uint64_t __attribute__((export_name("TS_KeysManager_as_NodeSigner"))) TS_KeysManager_as_NodeSigner(uint64_t this_arg) {
27163 LDKKeysManager this_arg_conv;
27164 this_arg_conv.inner = untag_ptr(this_arg);
27165 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27167 this_arg_conv.is_owned = false;
27168 LDKNodeSigner* ret_ret = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
27169 *ret_ret = KeysManager_as_NodeSigner(&this_arg_conv);
27170 return tag_ptr(ret_ret, true);
27173 uint64_t __attribute__((export_name("TS_KeysManager_as_SignerProvider"))) TS_KeysManager_as_SignerProvider(uint64_t this_arg) {
27174 LDKKeysManager this_arg_conv;
27175 this_arg_conv.inner = untag_ptr(this_arg);
27176 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27177 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27178 this_arg_conv.is_owned = false;
27179 LDKSignerProvider* ret_ret = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
27180 *ret_ret = KeysManager_as_SignerProvider(&this_arg_conv);
27181 return tag_ptr(ret_ret, true);
27184 void __attribute__((export_name("TS_PhantomKeysManager_free"))) TS_PhantomKeysManager_free(uint64_t this_obj) {
27185 LDKPhantomKeysManager this_obj_conv;
27186 this_obj_conv.inner = untag_ptr(this_obj);
27187 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27189 PhantomKeysManager_free(this_obj_conv);
27192 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_EntropySource"))) TS_PhantomKeysManager_as_EntropySource(uint64_t this_arg) {
27193 LDKPhantomKeysManager this_arg_conv;
27194 this_arg_conv.inner = untag_ptr(this_arg);
27195 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27197 this_arg_conv.is_owned = false;
27198 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
27199 *ret_ret = PhantomKeysManager_as_EntropySource(&this_arg_conv);
27200 return tag_ptr(ret_ret, true);
27203 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_NodeSigner"))) TS_PhantomKeysManager_as_NodeSigner(uint64_t this_arg) {
27204 LDKPhantomKeysManager this_arg_conv;
27205 this_arg_conv.inner = untag_ptr(this_arg);
27206 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27208 this_arg_conv.is_owned = false;
27209 LDKNodeSigner* ret_ret = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
27210 *ret_ret = PhantomKeysManager_as_NodeSigner(&this_arg_conv);
27211 return tag_ptr(ret_ret, true);
27214 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_SignerProvider"))) TS_PhantomKeysManager_as_SignerProvider(uint64_t this_arg) {
27215 LDKPhantomKeysManager this_arg_conv;
27216 this_arg_conv.inner = untag_ptr(this_arg);
27217 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27218 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27219 this_arg_conv.is_owned = false;
27220 LDKSignerProvider* ret_ret = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
27221 *ret_ret = PhantomKeysManager_as_SignerProvider(&this_arg_conv);
27222 return tag_ptr(ret_ret, true);
27225 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) {
27226 uint8_t seed_arr[32];
27227 CHECK(seed->arr_len == 32);
27228 memcpy(seed_arr, seed->elems, 32); FREE(seed);
27229 uint8_t (*seed_ref)[32] = &seed_arr;
27230 uint8_t cross_node_seed_arr[32];
27231 CHECK(cross_node_seed->arr_len == 32);
27232 memcpy(cross_node_seed_arr, cross_node_seed->elems, 32); FREE(cross_node_seed);
27233 uint8_t (*cross_node_seed_ref)[32] = &cross_node_seed_arr;
27234 LDKPhantomKeysManager ret_var = PhantomKeysManager_new(seed_ref, starting_time_secs, starting_time_nanos, cross_node_seed_ref);
27235 uint64_t ret_ref = 0;
27236 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27237 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27241 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) {
27242 LDKPhantomKeysManager this_arg_conv;
27243 this_arg_conv.inner = untag_ptr(this_arg);
27244 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27246 this_arg_conv.is_owned = false;
27247 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
27248 descriptors_constr.datalen = descriptors->arr_len;
27249 if (descriptors_constr.datalen > 0)
27250 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
27252 descriptors_constr.data = NULL;
27253 uint64_t* descriptors_vals = descriptors->elems;
27254 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
27255 uint64_t descriptors_conv_27 = descriptors_vals[b];
27256 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
27257 CHECK_ACCESS(descriptors_conv_27_ptr);
27258 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
27259 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
27260 descriptors_constr.data[b] = descriptors_conv_27_conv;
27263 LDKCVec_TxOutZ outputs_constr;
27264 outputs_constr.datalen = outputs->arr_len;
27265 if (outputs_constr.datalen > 0)
27266 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
27268 outputs_constr.data = NULL;
27269 uint64_t* outputs_vals = outputs->elems;
27270 for (size_t h = 0; h < outputs_constr.datalen; h++) {
27271 uint64_t outputs_conv_7 = outputs_vals[h];
27272 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
27273 CHECK_ACCESS(outputs_conv_7_ptr);
27274 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
27275 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
27276 outputs_constr.data[h] = outputs_conv_7_conv;
27279 LDKCVec_u8Z change_destination_script_ref;
27280 change_destination_script_ref.datalen = change_destination_script->arr_len;
27281 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
27282 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
27283 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
27284 *ret_conv = PhantomKeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
27285 return tag_ptr(ret_conv, true);
27288 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) {
27289 LDKPhantomKeysManager this_arg_conv;
27290 this_arg_conv.inner = untag_ptr(this_arg);
27291 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27292 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27293 this_arg_conv.is_owned = false;
27294 uint8_t params_arr[32];
27295 CHECK(params->arr_len == 32);
27296 memcpy(params_arr, params->elems, 32); FREE(params);
27297 uint8_t (*params_ref)[32] = ¶ms_arr;
27298 LDKInMemorySigner ret_var = PhantomKeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
27299 uint64_t ret_ref = 0;
27300 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27301 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27305 int8_tArray __attribute__((export_name("TS_PhantomKeysManager_get_node_secret_key"))) TS_PhantomKeysManager_get_node_secret_key(uint64_t this_arg) {
27306 LDKPhantomKeysManager this_arg_conv;
27307 this_arg_conv.inner = untag_ptr(this_arg);
27308 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27310 this_arg_conv.is_owned = false;
27311 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27312 memcpy(ret_arr->elems, PhantomKeysManager_get_node_secret_key(&this_arg_conv).bytes, 32);
27316 int8_tArray __attribute__((export_name("TS_PhantomKeysManager_get_phantom_node_secret_key"))) TS_PhantomKeysManager_get_phantom_node_secret_key(uint64_t this_arg) {
27317 LDKPhantomKeysManager this_arg_conv;
27318 this_arg_conv.inner = untag_ptr(this_arg);
27319 this_arg_conv.is_owned = ptr_is_owned(this_arg);
27320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27321 this_arg_conv.is_owned = false;
27322 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27323 memcpy(ret_arr->elems, PhantomKeysManager_get_phantom_node_secret_key(&this_arg_conv).bytes, 32);
27327 uint32_t __attribute__((export_name("TS_FailureCode_clone"))) TS_FailureCode_clone(uint64_t orig) {
27328 LDKFailureCode* orig_conv = (LDKFailureCode*)untag_ptr(orig);
27329 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_clone(orig_conv));
27333 uint32_t __attribute__((export_name("TS_FailureCode_temporary_node_failure"))) TS_FailureCode_temporary_node_failure() {
27334 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_temporary_node_failure());
27338 uint32_t __attribute__((export_name("TS_FailureCode_required_node_feature_missing"))) TS_FailureCode_required_node_feature_missing() {
27339 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_required_node_feature_missing());
27343 uint32_t __attribute__((export_name("TS_FailureCode_incorrect_or_unknown_payment_details"))) TS_FailureCode_incorrect_or_unknown_payment_details() {
27344 uint32_t ret_conv = LDKFailureCode_to_js(FailureCode_incorrect_or_unknown_payment_details());
27348 void __attribute__((export_name("TS_ChannelManager_free"))) TS_ChannelManager_free(uint64_t this_obj) {
27349 LDKChannelManager this_obj_conv;
27350 this_obj_conv.inner = untag_ptr(this_obj);
27351 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27353 ChannelManager_free(this_obj_conv);
27356 void __attribute__((export_name("TS_ChainParameters_free"))) TS_ChainParameters_free(uint64_t this_obj) {
27357 LDKChainParameters this_obj_conv;
27358 this_obj_conv.inner = untag_ptr(this_obj);
27359 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27361 ChainParameters_free(this_obj_conv);
27364 uint32_t __attribute__((export_name("TS_ChainParameters_get_network"))) TS_ChainParameters_get_network(uint64_t this_ptr) {
27365 LDKChainParameters this_ptr_conv;
27366 this_ptr_conv.inner = untag_ptr(this_ptr);
27367 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27368 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27369 this_ptr_conv.is_owned = false;
27370 uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
27374 void __attribute__((export_name("TS_ChainParameters_set_network"))) TS_ChainParameters_set_network(uint64_t this_ptr, uint32_t val) {
27375 LDKChainParameters this_ptr_conv;
27376 this_ptr_conv.inner = untag_ptr(this_ptr);
27377 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27379 this_ptr_conv.is_owned = false;
27380 LDKNetwork val_conv = LDKNetwork_from_js(val);
27381 ChainParameters_set_network(&this_ptr_conv, val_conv);
27384 uint64_t __attribute__((export_name("TS_ChainParameters_get_best_block"))) TS_ChainParameters_get_best_block(uint64_t this_ptr) {
27385 LDKChainParameters this_ptr_conv;
27386 this_ptr_conv.inner = untag_ptr(this_ptr);
27387 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27388 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27389 this_ptr_conv.is_owned = false;
27390 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
27391 uint64_t ret_ref = 0;
27392 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27393 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27397 void __attribute__((export_name("TS_ChainParameters_set_best_block"))) TS_ChainParameters_set_best_block(uint64_t this_ptr, uint64_t val) {
27398 LDKChainParameters this_ptr_conv;
27399 this_ptr_conv.inner = untag_ptr(this_ptr);
27400 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27401 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27402 this_ptr_conv.is_owned = false;
27403 LDKBestBlock val_conv;
27404 val_conv.inner = untag_ptr(val);
27405 val_conv.is_owned = ptr_is_owned(val);
27406 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27407 val_conv = BestBlock_clone(&val_conv);
27408 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
27411 uint64_t __attribute__((export_name("TS_ChainParameters_new"))) TS_ChainParameters_new(uint32_t network_arg, uint64_t best_block_arg) {
27412 LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
27413 LDKBestBlock best_block_arg_conv;
27414 best_block_arg_conv.inner = untag_ptr(best_block_arg);
27415 best_block_arg_conv.is_owned = ptr_is_owned(best_block_arg);
27416 CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
27417 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
27418 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
27419 uint64_t ret_ref = 0;
27420 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27421 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27425 static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
27426 LDKChainParameters ret_var = ChainParameters_clone(arg);
27427 uint64_t ret_ref = 0;
27428 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27429 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27432 int64_t __attribute__((export_name("TS_ChainParameters_clone_ptr"))) TS_ChainParameters_clone_ptr(uint64_t arg) {
27433 LDKChainParameters arg_conv;
27434 arg_conv.inner = untag_ptr(arg);
27435 arg_conv.is_owned = ptr_is_owned(arg);
27436 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27437 arg_conv.is_owned = false;
27438 int64_t ret_conv = ChainParameters_clone_ptr(&arg_conv);
27442 uint64_t __attribute__((export_name("TS_ChainParameters_clone"))) TS_ChainParameters_clone(uint64_t orig) {
27443 LDKChainParameters orig_conv;
27444 orig_conv.inner = untag_ptr(orig);
27445 orig_conv.is_owned = ptr_is_owned(orig);
27446 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27447 orig_conv.is_owned = false;
27448 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
27449 uint64_t ret_ref = 0;
27450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27451 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27455 void __attribute__((export_name("TS_CounterpartyForwardingInfo_free"))) TS_CounterpartyForwardingInfo_free(uint64_t this_obj) {
27456 LDKCounterpartyForwardingInfo this_obj_conv;
27457 this_obj_conv.inner = untag_ptr(this_obj);
27458 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27460 CounterpartyForwardingInfo_free(this_obj_conv);
27463 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_base_msat"))) TS_CounterpartyForwardingInfo_get_fee_base_msat(uint64_t this_ptr) {
27464 LDKCounterpartyForwardingInfo this_ptr_conv;
27465 this_ptr_conv.inner = untag_ptr(this_ptr);
27466 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27468 this_ptr_conv.is_owned = false;
27469 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
27473 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_base_msat"))) TS_CounterpartyForwardingInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
27474 LDKCounterpartyForwardingInfo this_ptr_conv;
27475 this_ptr_conv.inner = untag_ptr(this_ptr);
27476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27478 this_ptr_conv.is_owned = false;
27479 CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
27482 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
27483 LDKCounterpartyForwardingInfo this_ptr_conv;
27484 this_ptr_conv.inner = untag_ptr(this_ptr);
27485 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27487 this_ptr_conv.is_owned = false;
27488 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
27492 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
27493 LDKCounterpartyForwardingInfo this_ptr_conv;
27494 this_ptr_conv.inner = untag_ptr(this_ptr);
27495 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27497 this_ptr_conv.is_owned = false;
27498 CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
27501 int16_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
27502 LDKCounterpartyForwardingInfo this_ptr_conv;
27503 this_ptr_conv.inner = untag_ptr(this_ptr);
27504 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27506 this_ptr_conv.is_owned = false;
27507 int16_t ret_conv = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
27511 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
27512 LDKCounterpartyForwardingInfo this_ptr_conv;
27513 this_ptr_conv.inner = untag_ptr(this_ptr);
27514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27516 this_ptr_conv.is_owned = false;
27517 CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
27520 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) {
27521 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
27522 uint64_t ret_ref = 0;
27523 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27524 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27528 static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
27529 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
27530 uint64_t ret_ref = 0;
27531 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27532 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27535 int64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone_ptr"))) TS_CounterpartyForwardingInfo_clone_ptr(uint64_t arg) {
27536 LDKCounterpartyForwardingInfo arg_conv;
27537 arg_conv.inner = untag_ptr(arg);
27538 arg_conv.is_owned = ptr_is_owned(arg);
27539 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27540 arg_conv.is_owned = false;
27541 int64_t ret_conv = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
27545 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone"))) TS_CounterpartyForwardingInfo_clone(uint64_t orig) {
27546 LDKCounterpartyForwardingInfo orig_conv;
27547 orig_conv.inner = untag_ptr(orig);
27548 orig_conv.is_owned = ptr_is_owned(orig);
27549 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27550 orig_conv.is_owned = false;
27551 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
27552 uint64_t ret_ref = 0;
27553 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27554 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27558 void __attribute__((export_name("TS_ChannelCounterparty_free"))) TS_ChannelCounterparty_free(uint64_t this_obj) {
27559 LDKChannelCounterparty this_obj_conv;
27560 this_obj_conv.inner = untag_ptr(this_obj);
27561 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27562 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27563 ChannelCounterparty_free(this_obj_conv);
27566 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_get_node_id"))) TS_ChannelCounterparty_get_node_id(uint64_t this_ptr) {
27567 LDKChannelCounterparty this_ptr_conv;
27568 this_ptr_conv.inner = untag_ptr(this_ptr);
27569 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27570 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27571 this_ptr_conv.is_owned = false;
27572 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
27573 memcpy(ret_arr->elems, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
27577 void __attribute__((export_name("TS_ChannelCounterparty_set_node_id"))) TS_ChannelCounterparty_set_node_id(uint64_t this_ptr, int8_tArray val) {
27578 LDKChannelCounterparty this_ptr_conv;
27579 this_ptr_conv.inner = untag_ptr(this_ptr);
27580 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27582 this_ptr_conv.is_owned = false;
27583 LDKPublicKey val_ref;
27584 CHECK(val->arr_len == 33);
27585 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
27586 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
27589 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_features"))) TS_ChannelCounterparty_get_features(uint64_t this_ptr) {
27590 LDKChannelCounterparty this_ptr_conv;
27591 this_ptr_conv.inner = untag_ptr(this_ptr);
27592 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27594 this_ptr_conv.is_owned = false;
27595 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
27596 uint64_t ret_ref = 0;
27597 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27598 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27602 void __attribute__((export_name("TS_ChannelCounterparty_set_features"))) TS_ChannelCounterparty_set_features(uint64_t this_ptr, uint64_t val) {
27603 LDKChannelCounterparty this_ptr_conv;
27604 this_ptr_conv.inner = untag_ptr(this_ptr);
27605 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27607 this_ptr_conv.is_owned = false;
27608 LDKInitFeatures val_conv;
27609 val_conv.inner = untag_ptr(val);
27610 val_conv.is_owned = ptr_is_owned(val);
27611 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27612 val_conv = InitFeatures_clone(&val_conv);
27613 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
27616 int64_t __attribute__((export_name("TS_ChannelCounterparty_get_unspendable_punishment_reserve"))) TS_ChannelCounterparty_get_unspendable_punishment_reserve(uint64_t this_ptr) {
27617 LDKChannelCounterparty this_ptr_conv;
27618 this_ptr_conv.inner = untag_ptr(this_ptr);
27619 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27620 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27621 this_ptr_conv.is_owned = false;
27622 int64_t ret_conv = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
27626 void __attribute__((export_name("TS_ChannelCounterparty_set_unspendable_punishment_reserve"))) TS_ChannelCounterparty_set_unspendable_punishment_reserve(uint64_t this_ptr, int64_t val) {
27627 LDKChannelCounterparty this_ptr_conv;
27628 this_ptr_conv.inner = untag_ptr(this_ptr);
27629 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27631 this_ptr_conv.is_owned = false;
27632 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
27635 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_forwarding_info"))) TS_ChannelCounterparty_get_forwarding_info(uint64_t this_ptr) {
27636 LDKChannelCounterparty this_ptr_conv;
27637 this_ptr_conv.inner = untag_ptr(this_ptr);
27638 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27640 this_ptr_conv.is_owned = false;
27641 LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
27642 uint64_t ret_ref = 0;
27643 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27644 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27648 void __attribute__((export_name("TS_ChannelCounterparty_set_forwarding_info"))) TS_ChannelCounterparty_set_forwarding_info(uint64_t this_ptr, uint64_t val) {
27649 LDKChannelCounterparty this_ptr_conv;
27650 this_ptr_conv.inner = untag_ptr(this_ptr);
27651 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27652 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27653 this_ptr_conv.is_owned = false;
27654 LDKCounterpartyForwardingInfo val_conv;
27655 val_conv.inner = untag_ptr(val);
27656 val_conv.is_owned = ptr_is_owned(val);
27657 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27658 val_conv = CounterpartyForwardingInfo_clone(&val_conv);
27659 ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
27662 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(uint64_t this_ptr) {
27663 LDKChannelCounterparty this_ptr_conv;
27664 this_ptr_conv.inner = untag_ptr(this_ptr);
27665 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27667 this_ptr_conv.is_owned = false;
27668 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27669 *ret_copy = ChannelCounterparty_get_outbound_htlc_minimum_msat(&this_ptr_conv);
27670 uint64_t ret_ref = tag_ptr(ret_copy, true);
27674 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) {
27675 LDKChannelCounterparty this_ptr_conv;
27676 this_ptr_conv.inner = untag_ptr(this_ptr);
27677 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27678 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27679 this_ptr_conv.is_owned = false;
27680 void* val_ptr = untag_ptr(val);
27681 CHECK_ACCESS(val_ptr);
27682 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27683 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27684 ChannelCounterparty_set_outbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
27687 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(uint64_t this_ptr) {
27688 LDKChannelCounterparty this_ptr_conv;
27689 this_ptr_conv.inner = untag_ptr(this_ptr);
27690 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27692 this_ptr_conv.is_owned = false;
27693 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27694 *ret_copy = ChannelCounterparty_get_outbound_htlc_maximum_msat(&this_ptr_conv);
27695 uint64_t ret_ref = tag_ptr(ret_copy, true);
27699 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) {
27700 LDKChannelCounterparty this_ptr_conv;
27701 this_ptr_conv.inner = untag_ptr(this_ptr);
27702 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27704 this_ptr_conv.is_owned = false;
27705 void* val_ptr = untag_ptr(val);
27706 CHECK_ACCESS(val_ptr);
27707 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27708 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27709 ChannelCounterparty_set_outbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
27712 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) {
27713 LDKPublicKey node_id_arg_ref;
27714 CHECK(node_id_arg->arr_len == 33);
27715 memcpy(node_id_arg_ref.compressed_form, node_id_arg->elems, 33); FREE(node_id_arg);
27716 LDKInitFeatures features_arg_conv;
27717 features_arg_conv.inner = untag_ptr(features_arg);
27718 features_arg_conv.is_owned = ptr_is_owned(features_arg);
27719 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
27720 features_arg_conv = InitFeatures_clone(&features_arg_conv);
27721 LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
27722 forwarding_info_arg_conv.inner = untag_ptr(forwarding_info_arg);
27723 forwarding_info_arg_conv.is_owned = ptr_is_owned(forwarding_info_arg);
27724 CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
27725 forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
27726 void* outbound_htlc_minimum_msat_arg_ptr = untag_ptr(outbound_htlc_minimum_msat_arg);
27727 CHECK_ACCESS(outbound_htlc_minimum_msat_arg_ptr);
27728 LDKCOption_u64Z outbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_minimum_msat_arg_ptr);
27729 outbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_minimum_msat_arg));
27730 void* outbound_htlc_maximum_msat_arg_ptr = untag_ptr(outbound_htlc_maximum_msat_arg);
27731 CHECK_ACCESS(outbound_htlc_maximum_msat_arg_ptr);
27732 LDKCOption_u64Z outbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_maximum_msat_arg_ptr);
27733 outbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_maximum_msat_arg));
27734 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);
27735 uint64_t ret_ref = 0;
27736 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27737 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27741 static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
27742 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
27743 uint64_t ret_ref = 0;
27744 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27745 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27748 int64_t __attribute__((export_name("TS_ChannelCounterparty_clone_ptr"))) TS_ChannelCounterparty_clone_ptr(uint64_t arg) {
27749 LDKChannelCounterparty arg_conv;
27750 arg_conv.inner = untag_ptr(arg);
27751 arg_conv.is_owned = ptr_is_owned(arg);
27752 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27753 arg_conv.is_owned = false;
27754 int64_t ret_conv = ChannelCounterparty_clone_ptr(&arg_conv);
27758 uint64_t __attribute__((export_name("TS_ChannelCounterparty_clone"))) TS_ChannelCounterparty_clone(uint64_t orig) {
27759 LDKChannelCounterparty orig_conv;
27760 orig_conv.inner = untag_ptr(orig);
27761 orig_conv.is_owned = ptr_is_owned(orig);
27762 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27763 orig_conv.is_owned = false;
27764 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
27765 uint64_t ret_ref = 0;
27766 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27767 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27771 void __attribute__((export_name("TS_ChannelDetails_free"))) TS_ChannelDetails_free(uint64_t this_obj) {
27772 LDKChannelDetails this_obj_conv;
27773 this_obj_conv.inner = untag_ptr(this_obj);
27774 this_obj_conv.is_owned = ptr_is_owned(this_obj);
27775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27776 ChannelDetails_free(this_obj_conv);
27779 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_channel_id"))) TS_ChannelDetails_get_channel_id(uint64_t this_ptr) {
27780 LDKChannelDetails this_ptr_conv;
27781 this_ptr_conv.inner = untag_ptr(this_ptr);
27782 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27783 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27784 this_ptr_conv.is_owned = false;
27785 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
27786 memcpy(ret_arr->elems, *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
27790 void __attribute__((export_name("TS_ChannelDetails_set_channel_id"))) TS_ChannelDetails_set_channel_id(uint64_t this_ptr, int8_tArray val) {
27791 LDKChannelDetails this_ptr_conv;
27792 this_ptr_conv.inner = untag_ptr(this_ptr);
27793 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27795 this_ptr_conv.is_owned = false;
27796 LDKThirtyTwoBytes val_ref;
27797 CHECK(val->arr_len == 32);
27798 memcpy(val_ref.data, val->elems, 32); FREE(val);
27799 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
27802 uint64_t __attribute__((export_name("TS_ChannelDetails_get_counterparty"))) TS_ChannelDetails_get_counterparty(uint64_t this_ptr) {
27803 LDKChannelDetails this_ptr_conv;
27804 this_ptr_conv.inner = untag_ptr(this_ptr);
27805 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27807 this_ptr_conv.is_owned = false;
27808 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
27809 uint64_t ret_ref = 0;
27810 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27811 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27815 void __attribute__((export_name("TS_ChannelDetails_set_counterparty"))) TS_ChannelDetails_set_counterparty(uint64_t this_ptr, uint64_t val) {
27816 LDKChannelDetails this_ptr_conv;
27817 this_ptr_conv.inner = untag_ptr(this_ptr);
27818 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27820 this_ptr_conv.is_owned = false;
27821 LDKChannelCounterparty val_conv;
27822 val_conv.inner = untag_ptr(val);
27823 val_conv.is_owned = ptr_is_owned(val);
27824 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27825 val_conv = ChannelCounterparty_clone(&val_conv);
27826 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
27829 uint64_t __attribute__((export_name("TS_ChannelDetails_get_funding_txo"))) TS_ChannelDetails_get_funding_txo(uint64_t this_ptr) {
27830 LDKChannelDetails this_ptr_conv;
27831 this_ptr_conv.inner = untag_ptr(this_ptr);
27832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27834 this_ptr_conv.is_owned = false;
27835 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
27836 uint64_t ret_ref = 0;
27837 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27838 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27842 void __attribute__((export_name("TS_ChannelDetails_set_funding_txo"))) TS_ChannelDetails_set_funding_txo(uint64_t this_ptr, uint64_t val) {
27843 LDKChannelDetails this_ptr_conv;
27844 this_ptr_conv.inner = untag_ptr(this_ptr);
27845 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27846 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27847 this_ptr_conv.is_owned = false;
27848 LDKOutPoint val_conv;
27849 val_conv.inner = untag_ptr(val);
27850 val_conv.is_owned = ptr_is_owned(val);
27851 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27852 val_conv = OutPoint_clone(&val_conv);
27853 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
27856 uint64_t __attribute__((export_name("TS_ChannelDetails_get_channel_type"))) TS_ChannelDetails_get_channel_type(uint64_t this_ptr) {
27857 LDKChannelDetails this_ptr_conv;
27858 this_ptr_conv.inner = untag_ptr(this_ptr);
27859 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27861 this_ptr_conv.is_owned = false;
27862 LDKChannelTypeFeatures ret_var = ChannelDetails_get_channel_type(&this_ptr_conv);
27863 uint64_t ret_ref = 0;
27864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27865 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
27869 void __attribute__((export_name("TS_ChannelDetails_set_channel_type"))) TS_ChannelDetails_set_channel_type(uint64_t this_ptr, uint64_t val) {
27870 LDKChannelDetails this_ptr_conv;
27871 this_ptr_conv.inner = untag_ptr(this_ptr);
27872 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27874 this_ptr_conv.is_owned = false;
27875 LDKChannelTypeFeatures val_conv;
27876 val_conv.inner = untag_ptr(val);
27877 val_conv.is_owned = ptr_is_owned(val);
27878 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27879 val_conv = ChannelTypeFeatures_clone(&val_conv);
27880 ChannelDetails_set_channel_type(&this_ptr_conv, val_conv);
27883 uint64_t __attribute__((export_name("TS_ChannelDetails_get_short_channel_id"))) TS_ChannelDetails_get_short_channel_id(uint64_t this_ptr) {
27884 LDKChannelDetails this_ptr_conv;
27885 this_ptr_conv.inner = untag_ptr(this_ptr);
27886 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27888 this_ptr_conv.is_owned = false;
27889 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27890 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
27891 uint64_t ret_ref = tag_ptr(ret_copy, true);
27895 void __attribute__((export_name("TS_ChannelDetails_set_short_channel_id"))) TS_ChannelDetails_set_short_channel_id(uint64_t this_ptr, uint64_t val) {
27896 LDKChannelDetails this_ptr_conv;
27897 this_ptr_conv.inner = untag_ptr(this_ptr);
27898 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27900 this_ptr_conv.is_owned = false;
27901 void* val_ptr = untag_ptr(val);
27902 CHECK_ACCESS(val_ptr);
27903 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27904 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27905 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
27908 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_scid_alias"))) TS_ChannelDetails_get_outbound_scid_alias(uint64_t this_ptr) {
27909 LDKChannelDetails this_ptr_conv;
27910 this_ptr_conv.inner = untag_ptr(this_ptr);
27911 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27912 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27913 this_ptr_conv.is_owned = false;
27914 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27915 *ret_copy = ChannelDetails_get_outbound_scid_alias(&this_ptr_conv);
27916 uint64_t ret_ref = tag_ptr(ret_copy, true);
27920 void __attribute__((export_name("TS_ChannelDetails_set_outbound_scid_alias"))) TS_ChannelDetails_set_outbound_scid_alias(uint64_t this_ptr, uint64_t val) {
27921 LDKChannelDetails this_ptr_conv;
27922 this_ptr_conv.inner = untag_ptr(this_ptr);
27923 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27925 this_ptr_conv.is_owned = false;
27926 void* val_ptr = untag_ptr(val);
27927 CHECK_ACCESS(val_ptr);
27928 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27929 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27930 ChannelDetails_set_outbound_scid_alias(&this_ptr_conv, val_conv);
27933 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_scid_alias"))) TS_ChannelDetails_get_inbound_scid_alias(uint64_t this_ptr) {
27934 LDKChannelDetails this_ptr_conv;
27935 this_ptr_conv.inner = untag_ptr(this_ptr);
27936 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27938 this_ptr_conv.is_owned = false;
27939 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27940 *ret_copy = ChannelDetails_get_inbound_scid_alias(&this_ptr_conv);
27941 uint64_t ret_ref = tag_ptr(ret_copy, true);
27945 void __attribute__((export_name("TS_ChannelDetails_set_inbound_scid_alias"))) TS_ChannelDetails_set_inbound_scid_alias(uint64_t this_ptr, uint64_t val) {
27946 LDKChannelDetails this_ptr_conv;
27947 this_ptr_conv.inner = untag_ptr(this_ptr);
27948 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27950 this_ptr_conv.is_owned = false;
27951 void* val_ptr = untag_ptr(val);
27952 CHECK_ACCESS(val_ptr);
27953 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27954 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27955 ChannelDetails_set_inbound_scid_alias(&this_ptr_conv, val_conv);
27958 int64_t __attribute__((export_name("TS_ChannelDetails_get_channel_value_satoshis"))) TS_ChannelDetails_get_channel_value_satoshis(uint64_t this_ptr) {
27959 LDKChannelDetails this_ptr_conv;
27960 this_ptr_conv.inner = untag_ptr(this_ptr);
27961 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27963 this_ptr_conv.is_owned = false;
27964 int64_t ret_conv = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
27968 void __attribute__((export_name("TS_ChannelDetails_set_channel_value_satoshis"))) TS_ChannelDetails_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
27969 LDKChannelDetails this_ptr_conv;
27970 this_ptr_conv.inner = untag_ptr(this_ptr);
27971 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27972 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27973 this_ptr_conv.is_owned = false;
27974 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
27977 uint64_t __attribute__((export_name("TS_ChannelDetails_get_unspendable_punishment_reserve"))) TS_ChannelDetails_get_unspendable_punishment_reserve(uint64_t this_ptr) {
27978 LDKChannelDetails this_ptr_conv;
27979 this_ptr_conv.inner = untag_ptr(this_ptr);
27980 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27982 this_ptr_conv.is_owned = false;
27983 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
27984 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
27985 uint64_t ret_ref = tag_ptr(ret_copy, true);
27989 void __attribute__((export_name("TS_ChannelDetails_set_unspendable_punishment_reserve"))) TS_ChannelDetails_set_unspendable_punishment_reserve(uint64_t this_ptr, uint64_t val) {
27990 LDKChannelDetails this_ptr_conv;
27991 this_ptr_conv.inner = untag_ptr(this_ptr);
27992 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
27993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27994 this_ptr_conv.is_owned = false;
27995 void* val_ptr = untag_ptr(val);
27996 CHECK_ACCESS(val_ptr);
27997 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
27998 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
27999 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
28002 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_user_channel_id"))) TS_ChannelDetails_get_user_channel_id(uint64_t this_ptr) {
28003 LDKChannelDetails this_ptr_conv;
28004 this_ptr_conv.inner = untag_ptr(this_ptr);
28005 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28006 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28007 this_ptr_conv.is_owned = false;
28008 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
28009 memcpy(ret_arr->elems, ChannelDetails_get_user_channel_id(&this_ptr_conv).le_bytes, 16);
28013 void __attribute__((export_name("TS_ChannelDetails_set_user_channel_id"))) TS_ChannelDetails_set_user_channel_id(uint64_t this_ptr, int8_tArray val) {
28014 LDKChannelDetails this_ptr_conv;
28015 this_ptr_conv.inner = untag_ptr(this_ptr);
28016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28018 this_ptr_conv.is_owned = false;
28020 CHECK(val->arr_len == 16);
28021 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
28022 ChannelDetails_set_user_channel_id(&this_ptr_conv, val_ref);
28025 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) {
28026 LDKChannelDetails this_ptr_conv;
28027 this_ptr_conv.inner = untag_ptr(this_ptr);
28028 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28030 this_ptr_conv.is_owned = false;
28031 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
28032 *ret_copy = ChannelDetails_get_feerate_sat_per_1000_weight(&this_ptr_conv);
28033 uint64_t ret_ref = tag_ptr(ret_copy, true);
28037 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) {
28038 LDKChannelDetails this_ptr_conv;
28039 this_ptr_conv.inner = untag_ptr(this_ptr);
28040 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28042 this_ptr_conv.is_owned = false;
28043 void* val_ptr = untag_ptr(val);
28044 CHECK_ACCESS(val_ptr);
28045 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
28046 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
28047 ChannelDetails_set_feerate_sat_per_1000_weight(&this_ptr_conv, val_conv);
28050 int64_t __attribute__((export_name("TS_ChannelDetails_get_balance_msat"))) TS_ChannelDetails_get_balance_msat(uint64_t this_ptr) {
28051 LDKChannelDetails this_ptr_conv;
28052 this_ptr_conv.inner = untag_ptr(this_ptr);
28053 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28054 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28055 this_ptr_conv.is_owned = false;
28056 int64_t ret_conv = ChannelDetails_get_balance_msat(&this_ptr_conv);
28060 void __attribute__((export_name("TS_ChannelDetails_set_balance_msat"))) TS_ChannelDetails_set_balance_msat(uint64_t this_ptr, int64_t val) {
28061 LDKChannelDetails this_ptr_conv;
28062 this_ptr_conv.inner = untag_ptr(this_ptr);
28063 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28064 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28065 this_ptr_conv.is_owned = false;
28066 ChannelDetails_set_balance_msat(&this_ptr_conv, val);
28069 int64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_capacity_msat"))) TS_ChannelDetails_get_outbound_capacity_msat(uint64_t this_ptr) {
28070 LDKChannelDetails this_ptr_conv;
28071 this_ptr_conv.inner = untag_ptr(this_ptr);
28072 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28073 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28074 this_ptr_conv.is_owned = false;
28075 int64_t ret_conv = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
28079 void __attribute__((export_name("TS_ChannelDetails_set_outbound_capacity_msat"))) TS_ChannelDetails_set_outbound_capacity_msat(uint64_t this_ptr, int64_t val) {
28080 LDKChannelDetails this_ptr_conv;
28081 this_ptr_conv.inner = untag_ptr(this_ptr);
28082 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28083 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28084 this_ptr_conv.is_owned = false;
28085 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
28088 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) {
28089 LDKChannelDetails this_ptr_conv;
28090 this_ptr_conv.inner = untag_ptr(this_ptr);
28091 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28092 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28093 this_ptr_conv.is_owned = false;
28094 int64_t ret_conv = ChannelDetails_get_next_outbound_htlc_limit_msat(&this_ptr_conv);
28098 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) {
28099 LDKChannelDetails this_ptr_conv;
28100 this_ptr_conv.inner = untag_ptr(this_ptr);
28101 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28102 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28103 this_ptr_conv.is_owned = false;
28104 ChannelDetails_set_next_outbound_htlc_limit_msat(&this_ptr_conv, val);
28107 int64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_capacity_msat"))) TS_ChannelDetails_get_inbound_capacity_msat(uint64_t this_ptr) {
28108 LDKChannelDetails this_ptr_conv;
28109 this_ptr_conv.inner = untag_ptr(this_ptr);
28110 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28112 this_ptr_conv.is_owned = false;
28113 int64_t ret_conv = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
28117 void __attribute__((export_name("TS_ChannelDetails_set_inbound_capacity_msat"))) TS_ChannelDetails_set_inbound_capacity_msat(uint64_t this_ptr, int64_t val) {
28118 LDKChannelDetails this_ptr_conv;
28119 this_ptr_conv.inner = untag_ptr(this_ptr);
28120 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28122 this_ptr_conv.is_owned = false;
28123 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
28126 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations_required"))) TS_ChannelDetails_get_confirmations_required(uint64_t this_ptr) {
28127 LDKChannelDetails this_ptr_conv;
28128 this_ptr_conv.inner = untag_ptr(this_ptr);
28129 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28131 this_ptr_conv.is_owned = false;
28132 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
28133 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
28134 uint64_t ret_ref = tag_ptr(ret_copy, true);
28138 void __attribute__((export_name("TS_ChannelDetails_set_confirmations_required"))) TS_ChannelDetails_set_confirmations_required(uint64_t this_ptr, uint64_t val) {
28139 LDKChannelDetails this_ptr_conv;
28140 this_ptr_conv.inner = untag_ptr(this_ptr);
28141 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28143 this_ptr_conv.is_owned = false;
28144 void* val_ptr = untag_ptr(val);
28145 CHECK_ACCESS(val_ptr);
28146 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
28147 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
28148 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
28151 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations"))) TS_ChannelDetails_get_confirmations(uint64_t this_ptr) {
28152 LDKChannelDetails this_ptr_conv;
28153 this_ptr_conv.inner = untag_ptr(this_ptr);
28154 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28156 this_ptr_conv.is_owned = false;
28157 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
28158 *ret_copy = ChannelDetails_get_confirmations(&this_ptr_conv);
28159 uint64_t ret_ref = tag_ptr(ret_copy, true);
28163 void __attribute__((export_name("TS_ChannelDetails_set_confirmations"))) TS_ChannelDetails_set_confirmations(uint64_t this_ptr, uint64_t val) {
28164 LDKChannelDetails this_ptr_conv;
28165 this_ptr_conv.inner = untag_ptr(this_ptr);
28166 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28168 this_ptr_conv.is_owned = false;
28169 void* val_ptr = untag_ptr(val);
28170 CHECK_ACCESS(val_ptr);
28171 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
28172 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
28173 ChannelDetails_set_confirmations(&this_ptr_conv, val_conv);
28176 uint64_t __attribute__((export_name("TS_ChannelDetails_get_force_close_spend_delay"))) TS_ChannelDetails_get_force_close_spend_delay(uint64_t this_ptr) {
28177 LDKChannelDetails this_ptr_conv;
28178 this_ptr_conv.inner = untag_ptr(this_ptr);
28179 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28180 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28181 this_ptr_conv.is_owned = false;
28182 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
28183 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
28184 uint64_t ret_ref = tag_ptr(ret_copy, true);
28188 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) {
28189 LDKChannelDetails this_ptr_conv;
28190 this_ptr_conv.inner = untag_ptr(this_ptr);
28191 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28192 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28193 this_ptr_conv.is_owned = false;
28194 void* val_ptr = untag_ptr(val);
28195 CHECK_ACCESS(val_ptr);
28196 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
28197 val_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(val));
28198 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
28201 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_outbound"))) TS_ChannelDetails_get_is_outbound(uint64_t this_ptr) {
28202 LDKChannelDetails this_ptr_conv;
28203 this_ptr_conv.inner = untag_ptr(this_ptr);
28204 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28206 this_ptr_conv.is_owned = false;
28207 jboolean ret_conv = ChannelDetails_get_is_outbound(&this_ptr_conv);
28211 void __attribute__((export_name("TS_ChannelDetails_set_is_outbound"))) TS_ChannelDetails_set_is_outbound(uint64_t this_ptr, jboolean val) {
28212 LDKChannelDetails this_ptr_conv;
28213 this_ptr_conv.inner = untag_ptr(this_ptr);
28214 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28215 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28216 this_ptr_conv.is_owned = false;
28217 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
28220 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_channel_ready"))) TS_ChannelDetails_get_is_channel_ready(uint64_t this_ptr) {
28221 LDKChannelDetails this_ptr_conv;
28222 this_ptr_conv.inner = untag_ptr(this_ptr);
28223 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28225 this_ptr_conv.is_owned = false;
28226 jboolean ret_conv = ChannelDetails_get_is_channel_ready(&this_ptr_conv);
28230 void __attribute__((export_name("TS_ChannelDetails_set_is_channel_ready"))) TS_ChannelDetails_set_is_channel_ready(uint64_t this_ptr, jboolean val) {
28231 LDKChannelDetails this_ptr_conv;
28232 this_ptr_conv.inner = untag_ptr(this_ptr);
28233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28235 this_ptr_conv.is_owned = false;
28236 ChannelDetails_set_is_channel_ready(&this_ptr_conv, val);
28239 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_usable"))) TS_ChannelDetails_get_is_usable(uint64_t this_ptr) {
28240 LDKChannelDetails this_ptr_conv;
28241 this_ptr_conv.inner = untag_ptr(this_ptr);
28242 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28244 this_ptr_conv.is_owned = false;
28245 jboolean ret_conv = ChannelDetails_get_is_usable(&this_ptr_conv);
28249 void __attribute__((export_name("TS_ChannelDetails_set_is_usable"))) TS_ChannelDetails_set_is_usable(uint64_t this_ptr, jboolean val) {
28250 LDKChannelDetails this_ptr_conv;
28251 this_ptr_conv.inner = untag_ptr(this_ptr);
28252 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28254 this_ptr_conv.is_owned = false;
28255 ChannelDetails_set_is_usable(&this_ptr_conv, val);
28258 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_public"))) TS_ChannelDetails_get_is_public(uint64_t this_ptr) {
28259 LDKChannelDetails this_ptr_conv;
28260 this_ptr_conv.inner = untag_ptr(this_ptr);
28261 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28262 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28263 this_ptr_conv.is_owned = false;
28264 jboolean ret_conv = ChannelDetails_get_is_public(&this_ptr_conv);
28268 void __attribute__((export_name("TS_ChannelDetails_set_is_public"))) TS_ChannelDetails_set_is_public(uint64_t this_ptr, jboolean val) {
28269 LDKChannelDetails this_ptr_conv;
28270 this_ptr_conv.inner = untag_ptr(this_ptr);
28271 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28272 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28273 this_ptr_conv.is_owned = false;
28274 ChannelDetails_set_is_public(&this_ptr_conv, val);
28277 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_minimum_msat"))) TS_ChannelDetails_get_inbound_htlc_minimum_msat(uint64_t this_ptr) {
28278 LDKChannelDetails this_ptr_conv;
28279 this_ptr_conv.inner = untag_ptr(this_ptr);
28280 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28282 this_ptr_conv.is_owned = false;
28283 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28284 *ret_copy = ChannelDetails_get_inbound_htlc_minimum_msat(&this_ptr_conv);
28285 uint64_t ret_ref = tag_ptr(ret_copy, true);
28289 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) {
28290 LDKChannelDetails this_ptr_conv;
28291 this_ptr_conv.inner = untag_ptr(this_ptr);
28292 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28294 this_ptr_conv.is_owned = false;
28295 void* val_ptr = untag_ptr(val);
28296 CHECK_ACCESS(val_ptr);
28297 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
28298 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
28299 ChannelDetails_set_inbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
28302 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_maximum_msat"))) TS_ChannelDetails_get_inbound_htlc_maximum_msat(uint64_t this_ptr) {
28303 LDKChannelDetails this_ptr_conv;
28304 this_ptr_conv.inner = untag_ptr(this_ptr);
28305 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28306 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28307 this_ptr_conv.is_owned = false;
28308 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28309 *ret_copy = ChannelDetails_get_inbound_htlc_maximum_msat(&this_ptr_conv);
28310 uint64_t ret_ref = tag_ptr(ret_copy, true);
28314 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) {
28315 LDKChannelDetails this_ptr_conv;
28316 this_ptr_conv.inner = untag_ptr(this_ptr);
28317 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28318 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28319 this_ptr_conv.is_owned = false;
28320 void* val_ptr = untag_ptr(val);
28321 CHECK_ACCESS(val_ptr);
28322 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
28323 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
28324 ChannelDetails_set_inbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
28327 uint64_t __attribute__((export_name("TS_ChannelDetails_get_config"))) TS_ChannelDetails_get_config(uint64_t this_ptr) {
28328 LDKChannelDetails this_ptr_conv;
28329 this_ptr_conv.inner = untag_ptr(this_ptr);
28330 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28332 this_ptr_conv.is_owned = false;
28333 LDKChannelConfig ret_var = ChannelDetails_get_config(&this_ptr_conv);
28334 uint64_t ret_ref = 0;
28335 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28336 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28340 void __attribute__((export_name("TS_ChannelDetails_set_config"))) TS_ChannelDetails_set_config(uint64_t this_ptr, uint64_t val) {
28341 LDKChannelDetails this_ptr_conv;
28342 this_ptr_conv.inner = untag_ptr(this_ptr);
28343 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28345 this_ptr_conv.is_owned = false;
28346 LDKChannelConfig val_conv;
28347 val_conv.inner = untag_ptr(val);
28348 val_conv.is_owned = ptr_is_owned(val);
28349 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
28350 val_conv = ChannelConfig_clone(&val_conv);
28351 ChannelDetails_set_config(&this_ptr_conv, val_conv);
28354 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) {
28355 LDKThirtyTwoBytes channel_id_arg_ref;
28356 CHECK(channel_id_arg->arr_len == 32);
28357 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
28358 LDKChannelCounterparty counterparty_arg_conv;
28359 counterparty_arg_conv.inner = untag_ptr(counterparty_arg);
28360 counterparty_arg_conv.is_owned = ptr_is_owned(counterparty_arg);
28361 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
28362 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
28363 LDKOutPoint funding_txo_arg_conv;
28364 funding_txo_arg_conv.inner = untag_ptr(funding_txo_arg);
28365 funding_txo_arg_conv.is_owned = ptr_is_owned(funding_txo_arg);
28366 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
28367 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
28368 LDKChannelTypeFeatures channel_type_arg_conv;
28369 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
28370 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
28371 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
28372 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
28373 void* short_channel_id_arg_ptr = untag_ptr(short_channel_id_arg);
28374 CHECK_ACCESS(short_channel_id_arg_ptr);
28375 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_arg_ptr);
28376 short_channel_id_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_arg));
28377 void* outbound_scid_alias_arg_ptr = untag_ptr(outbound_scid_alias_arg);
28378 CHECK_ACCESS(outbound_scid_alias_arg_ptr);
28379 LDKCOption_u64Z outbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(outbound_scid_alias_arg_ptr);
28380 outbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_scid_alias_arg));
28381 void* inbound_scid_alias_arg_ptr = untag_ptr(inbound_scid_alias_arg);
28382 CHECK_ACCESS(inbound_scid_alias_arg_ptr);
28383 LDKCOption_u64Z inbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(inbound_scid_alias_arg_ptr);
28384 inbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_scid_alias_arg));
28385 void* unspendable_punishment_reserve_arg_ptr = untag_ptr(unspendable_punishment_reserve_arg);
28386 CHECK_ACCESS(unspendable_punishment_reserve_arg_ptr);
28387 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(unspendable_punishment_reserve_arg_ptr);
28388 LDKU128 user_channel_id_arg_ref;
28389 CHECK(user_channel_id_arg->arr_len == 16);
28390 memcpy(user_channel_id_arg_ref.le_bytes, user_channel_id_arg->elems, 16); FREE(user_channel_id_arg);
28391 void* feerate_sat_per_1000_weight_arg_ptr = untag_ptr(feerate_sat_per_1000_weight_arg);
28392 CHECK_ACCESS(feerate_sat_per_1000_weight_arg_ptr);
28393 LDKCOption_u32Z feerate_sat_per_1000_weight_arg_conv = *(LDKCOption_u32Z*)(feerate_sat_per_1000_weight_arg_ptr);
28394 feerate_sat_per_1000_weight_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(feerate_sat_per_1000_weight_arg));
28395 void* confirmations_required_arg_ptr = untag_ptr(confirmations_required_arg);
28396 CHECK_ACCESS(confirmations_required_arg_ptr);
28397 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(confirmations_required_arg_ptr);
28398 confirmations_required_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_required_arg));
28399 void* confirmations_arg_ptr = untag_ptr(confirmations_arg);
28400 CHECK_ACCESS(confirmations_arg_ptr);
28401 LDKCOption_u32Z confirmations_arg_conv = *(LDKCOption_u32Z*)(confirmations_arg_ptr);
28402 confirmations_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_arg));
28403 void* force_close_spend_delay_arg_ptr = untag_ptr(force_close_spend_delay_arg);
28404 CHECK_ACCESS(force_close_spend_delay_arg_ptr);
28405 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(force_close_spend_delay_arg_ptr);
28406 force_close_spend_delay_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(force_close_spend_delay_arg));
28407 void* inbound_htlc_minimum_msat_arg_ptr = untag_ptr(inbound_htlc_minimum_msat_arg);
28408 CHECK_ACCESS(inbound_htlc_minimum_msat_arg_ptr);
28409 LDKCOption_u64Z inbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_minimum_msat_arg_ptr);
28410 inbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_minimum_msat_arg));
28411 void* inbound_htlc_maximum_msat_arg_ptr = untag_ptr(inbound_htlc_maximum_msat_arg);
28412 CHECK_ACCESS(inbound_htlc_maximum_msat_arg_ptr);
28413 LDKCOption_u64Z inbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_maximum_msat_arg_ptr);
28414 inbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_maximum_msat_arg));
28415 LDKChannelConfig config_arg_conv;
28416 config_arg_conv.inner = untag_ptr(config_arg);
28417 config_arg_conv.is_owned = ptr_is_owned(config_arg);
28418 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_arg_conv);
28419 config_arg_conv = ChannelConfig_clone(&config_arg_conv);
28420 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);
28421 uint64_t ret_ref = 0;
28422 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28423 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28427 static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
28428 LDKChannelDetails ret_var = ChannelDetails_clone(arg);
28429 uint64_t ret_ref = 0;
28430 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28431 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28434 int64_t __attribute__((export_name("TS_ChannelDetails_clone_ptr"))) TS_ChannelDetails_clone_ptr(uint64_t arg) {
28435 LDKChannelDetails arg_conv;
28436 arg_conv.inner = untag_ptr(arg);
28437 arg_conv.is_owned = ptr_is_owned(arg);
28438 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28439 arg_conv.is_owned = false;
28440 int64_t ret_conv = ChannelDetails_clone_ptr(&arg_conv);
28444 uint64_t __attribute__((export_name("TS_ChannelDetails_clone"))) TS_ChannelDetails_clone(uint64_t orig) {
28445 LDKChannelDetails orig_conv;
28446 orig_conv.inner = untag_ptr(orig);
28447 orig_conv.is_owned = ptr_is_owned(orig);
28448 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28449 orig_conv.is_owned = false;
28450 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
28451 uint64_t ret_ref = 0;
28452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28453 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28457 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_payment_scid"))) TS_ChannelDetails_get_inbound_payment_scid(uint64_t this_arg) {
28458 LDKChannelDetails this_arg_conv;
28459 this_arg_conv.inner = untag_ptr(this_arg);
28460 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28461 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28462 this_arg_conv.is_owned = false;
28463 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28464 *ret_copy = ChannelDetails_get_inbound_payment_scid(&this_arg_conv);
28465 uint64_t ret_ref = tag_ptr(ret_copy, true);
28469 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_payment_scid"))) TS_ChannelDetails_get_outbound_payment_scid(uint64_t this_arg) {
28470 LDKChannelDetails this_arg_conv;
28471 this_arg_conv.inner = untag_ptr(this_arg);
28472 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28473 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28474 this_arg_conv.is_owned = false;
28475 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
28476 *ret_copy = ChannelDetails_get_outbound_payment_scid(&this_arg_conv);
28477 uint64_t ret_ref = tag_ptr(ret_copy, true);
28481 void __attribute__((export_name("TS_RecentPaymentDetails_free"))) TS_RecentPaymentDetails_free(uint64_t this_ptr) {
28482 if (!ptr_is_owned(this_ptr)) return;
28483 void* this_ptr_ptr = untag_ptr(this_ptr);
28484 CHECK_ACCESS(this_ptr_ptr);
28485 LDKRecentPaymentDetails this_ptr_conv = *(LDKRecentPaymentDetails*)(this_ptr_ptr);
28486 FREE(untag_ptr(this_ptr));
28487 RecentPaymentDetails_free(this_ptr_conv);
28490 static inline uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg) {
28491 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28492 *ret_copy = RecentPaymentDetails_clone(arg);
28493 uint64_t ret_ref = tag_ptr(ret_copy, true);
28496 int64_t __attribute__((export_name("TS_RecentPaymentDetails_clone_ptr"))) TS_RecentPaymentDetails_clone_ptr(uint64_t arg) {
28497 LDKRecentPaymentDetails* arg_conv = (LDKRecentPaymentDetails*)untag_ptr(arg);
28498 int64_t ret_conv = RecentPaymentDetails_clone_ptr(arg_conv);
28502 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_clone"))) TS_RecentPaymentDetails_clone(uint64_t orig) {
28503 LDKRecentPaymentDetails* orig_conv = (LDKRecentPaymentDetails*)untag_ptr(orig);
28504 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28505 *ret_copy = RecentPaymentDetails_clone(orig_conv);
28506 uint64_t ret_ref = tag_ptr(ret_copy, true);
28510 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_pending"))) TS_RecentPaymentDetails_pending(int8_tArray payment_hash, int64_t total_msat) {
28511 LDKThirtyTwoBytes payment_hash_ref;
28512 CHECK(payment_hash->arr_len == 32);
28513 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28514 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28515 *ret_copy = RecentPaymentDetails_pending(payment_hash_ref, total_msat);
28516 uint64_t ret_ref = tag_ptr(ret_copy, true);
28520 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_fulfilled"))) TS_RecentPaymentDetails_fulfilled(int8_tArray payment_hash) {
28521 LDKThirtyTwoBytes payment_hash_ref;
28522 CHECK(payment_hash->arr_len == 32);
28523 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28524 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28525 *ret_copy = RecentPaymentDetails_fulfilled(payment_hash_ref);
28526 uint64_t ret_ref = tag_ptr(ret_copy, true);
28530 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_abandoned"))) TS_RecentPaymentDetails_abandoned(int8_tArray payment_hash) {
28531 LDKThirtyTwoBytes payment_hash_ref;
28532 CHECK(payment_hash->arr_len == 32);
28533 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28534 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28535 *ret_copy = RecentPaymentDetails_abandoned(payment_hash_ref);
28536 uint64_t ret_ref = tag_ptr(ret_copy, true);
28540 void __attribute__((export_name("TS_PhantomRouteHints_free"))) TS_PhantomRouteHints_free(uint64_t this_obj) {
28541 LDKPhantomRouteHints this_obj_conv;
28542 this_obj_conv.inner = untag_ptr(this_obj);
28543 this_obj_conv.is_owned = ptr_is_owned(this_obj);
28544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28545 PhantomRouteHints_free(this_obj_conv);
28548 uint64_tArray __attribute__((export_name("TS_PhantomRouteHints_get_channels"))) TS_PhantomRouteHints_get_channels(uint64_t this_ptr) {
28549 LDKPhantomRouteHints this_ptr_conv;
28550 this_ptr_conv.inner = untag_ptr(this_ptr);
28551 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28552 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28553 this_ptr_conv.is_owned = false;
28554 LDKCVec_ChannelDetailsZ ret_var = PhantomRouteHints_get_channels(&this_ptr_conv);
28555 uint64_tArray ret_arr = NULL;
28556 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28557 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28558 for (size_t q = 0; q < ret_var.datalen; q++) {
28559 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28560 uint64_t ret_conv_16_ref = 0;
28561 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28562 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28563 ret_arr_ptr[q] = ret_conv_16_ref;
28566 FREE(ret_var.data);
28570 void __attribute__((export_name("TS_PhantomRouteHints_set_channels"))) TS_PhantomRouteHints_set_channels(uint64_t this_ptr, uint64_tArray val) {
28571 LDKPhantomRouteHints this_ptr_conv;
28572 this_ptr_conv.inner = untag_ptr(this_ptr);
28573 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28575 this_ptr_conv.is_owned = false;
28576 LDKCVec_ChannelDetailsZ val_constr;
28577 val_constr.datalen = val->arr_len;
28578 if (val_constr.datalen > 0)
28579 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
28581 val_constr.data = NULL;
28582 uint64_t* val_vals = val->elems;
28583 for (size_t q = 0; q < val_constr.datalen; q++) {
28584 uint64_t val_conv_16 = val_vals[q];
28585 LDKChannelDetails val_conv_16_conv;
28586 val_conv_16_conv.inner = untag_ptr(val_conv_16);
28587 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
28588 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
28589 val_conv_16_conv = ChannelDetails_clone(&val_conv_16_conv);
28590 val_constr.data[q] = val_conv_16_conv;
28593 PhantomRouteHints_set_channels(&this_ptr_conv, val_constr);
28596 int64_t __attribute__((export_name("TS_PhantomRouteHints_get_phantom_scid"))) TS_PhantomRouteHints_get_phantom_scid(uint64_t this_ptr) {
28597 LDKPhantomRouteHints this_ptr_conv;
28598 this_ptr_conv.inner = untag_ptr(this_ptr);
28599 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28601 this_ptr_conv.is_owned = false;
28602 int64_t ret_conv = PhantomRouteHints_get_phantom_scid(&this_ptr_conv);
28606 void __attribute__((export_name("TS_PhantomRouteHints_set_phantom_scid"))) TS_PhantomRouteHints_set_phantom_scid(uint64_t this_ptr, int64_t val) {
28607 LDKPhantomRouteHints this_ptr_conv;
28608 this_ptr_conv.inner = untag_ptr(this_ptr);
28609 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28611 this_ptr_conv.is_owned = false;
28612 PhantomRouteHints_set_phantom_scid(&this_ptr_conv, val);
28615 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_get_real_node_pubkey"))) TS_PhantomRouteHints_get_real_node_pubkey(uint64_t this_ptr) {
28616 LDKPhantomRouteHints this_ptr_conv;
28617 this_ptr_conv.inner = untag_ptr(this_ptr);
28618 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28620 this_ptr_conv.is_owned = false;
28621 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28622 memcpy(ret_arr->elems, PhantomRouteHints_get_real_node_pubkey(&this_ptr_conv).compressed_form, 33);
28626 void __attribute__((export_name("TS_PhantomRouteHints_set_real_node_pubkey"))) TS_PhantomRouteHints_set_real_node_pubkey(uint64_t this_ptr, int8_tArray val) {
28627 LDKPhantomRouteHints this_ptr_conv;
28628 this_ptr_conv.inner = untag_ptr(this_ptr);
28629 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
28630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28631 this_ptr_conv.is_owned = false;
28632 LDKPublicKey val_ref;
28633 CHECK(val->arr_len == 33);
28634 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28635 PhantomRouteHints_set_real_node_pubkey(&this_ptr_conv, val_ref);
28638 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) {
28639 LDKCVec_ChannelDetailsZ channels_arg_constr;
28640 channels_arg_constr.datalen = channels_arg->arr_len;
28641 if (channels_arg_constr.datalen > 0)
28642 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
28644 channels_arg_constr.data = NULL;
28645 uint64_t* channels_arg_vals = channels_arg->elems;
28646 for (size_t q = 0; q < channels_arg_constr.datalen; q++) {
28647 uint64_t channels_arg_conv_16 = channels_arg_vals[q];
28648 LDKChannelDetails channels_arg_conv_16_conv;
28649 channels_arg_conv_16_conv.inner = untag_ptr(channels_arg_conv_16);
28650 channels_arg_conv_16_conv.is_owned = ptr_is_owned(channels_arg_conv_16);
28651 CHECK_INNER_FIELD_ACCESS_OR_NULL(channels_arg_conv_16_conv);
28652 channels_arg_conv_16_conv = ChannelDetails_clone(&channels_arg_conv_16_conv);
28653 channels_arg_constr.data[q] = channels_arg_conv_16_conv;
28655 FREE(channels_arg);
28656 LDKPublicKey real_node_pubkey_arg_ref;
28657 CHECK(real_node_pubkey_arg->arr_len == 33);
28658 memcpy(real_node_pubkey_arg_ref.compressed_form, real_node_pubkey_arg->elems, 33); FREE(real_node_pubkey_arg);
28659 LDKPhantomRouteHints ret_var = PhantomRouteHints_new(channels_arg_constr, phantom_scid_arg, real_node_pubkey_arg_ref);
28660 uint64_t ret_ref = 0;
28661 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28662 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28666 static inline uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg) {
28667 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(arg);
28668 uint64_t ret_ref = 0;
28669 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28670 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28673 int64_t __attribute__((export_name("TS_PhantomRouteHints_clone_ptr"))) TS_PhantomRouteHints_clone_ptr(uint64_t arg) {
28674 LDKPhantomRouteHints arg_conv;
28675 arg_conv.inner = untag_ptr(arg);
28676 arg_conv.is_owned = ptr_is_owned(arg);
28677 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28678 arg_conv.is_owned = false;
28679 int64_t ret_conv = PhantomRouteHints_clone_ptr(&arg_conv);
28683 uint64_t __attribute__((export_name("TS_PhantomRouteHints_clone"))) TS_PhantomRouteHints_clone(uint64_t orig) {
28684 LDKPhantomRouteHints orig_conv;
28685 orig_conv.inner = untag_ptr(orig);
28686 orig_conv.is_owned = ptr_is_owned(orig);
28687 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28688 orig_conv.is_owned = false;
28689 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(&orig_conv);
28690 uint64_t ret_ref = 0;
28691 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28692 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28696 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) {
28697 void* fee_est_ptr = untag_ptr(fee_est);
28698 CHECK_ACCESS(fee_est_ptr);
28699 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(fee_est_ptr);
28700 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
28701 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28702 LDKFeeEstimator_JCalls_cloned(&fee_est_conv);
28704 void* chain_monitor_ptr = untag_ptr(chain_monitor);
28705 CHECK_ACCESS(chain_monitor_ptr);
28706 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
28707 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
28708 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28709 LDKWatch_JCalls_cloned(&chain_monitor_conv);
28711 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
28712 CHECK_ACCESS(tx_broadcaster_ptr);
28713 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
28714 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
28715 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28716 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
28718 void* router_ptr = untag_ptr(router);
28719 CHECK_ACCESS(router_ptr);
28720 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
28721 if (router_conv.free == LDKRouter_JCalls_free) {
28722 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28723 LDKRouter_JCalls_cloned(&router_conv);
28725 void* logger_ptr = untag_ptr(logger);
28726 CHECK_ACCESS(logger_ptr);
28727 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
28728 if (logger_conv.free == LDKLogger_JCalls_free) {
28729 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28730 LDKLogger_JCalls_cloned(&logger_conv);
28732 void* entropy_source_ptr = untag_ptr(entropy_source);
28733 CHECK_ACCESS(entropy_source_ptr);
28734 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
28735 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
28736 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28737 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
28739 void* node_signer_ptr = untag_ptr(node_signer);
28740 CHECK_ACCESS(node_signer_ptr);
28741 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
28742 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
28743 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28744 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
28746 void* signer_provider_ptr = untag_ptr(signer_provider);
28747 CHECK_ACCESS(signer_provider_ptr);
28748 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
28749 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
28750 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28751 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
28753 LDKUserConfig config_conv;
28754 config_conv.inner = untag_ptr(config);
28755 config_conv.is_owned = ptr_is_owned(config);
28756 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
28757 config_conv = UserConfig_clone(&config_conv);
28758 LDKChainParameters params_conv;
28759 params_conv.inner = untag_ptr(params);
28760 params_conv.is_owned = ptr_is_owned(params);
28761 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
28762 params_conv = ChainParameters_clone(¶ms_conv);
28763 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);
28764 uint64_t ret_ref = 0;
28765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28766 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28770 uint64_t __attribute__((export_name("TS_ChannelManager_get_current_default_configuration"))) TS_ChannelManager_get_current_default_configuration(uint64_t this_arg) {
28771 LDKChannelManager this_arg_conv;
28772 this_arg_conv.inner = untag_ptr(this_arg);
28773 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28775 this_arg_conv.is_owned = false;
28776 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
28777 uint64_t ret_ref = 0;
28778 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28779 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
28783 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) {
28784 LDKChannelManager this_arg_conv;
28785 this_arg_conv.inner = untag_ptr(this_arg);
28786 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28788 this_arg_conv.is_owned = false;
28789 LDKPublicKey their_network_key_ref;
28790 CHECK(their_network_key->arr_len == 33);
28791 memcpy(their_network_key_ref.compressed_form, their_network_key->elems, 33); FREE(their_network_key);
28792 LDKU128 user_channel_id_ref;
28793 CHECK(user_channel_id->arr_len == 16);
28794 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
28795 LDKUserConfig override_config_conv;
28796 override_config_conv.inner = untag_ptr(override_config);
28797 override_config_conv.is_owned = ptr_is_owned(override_config);
28798 CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
28799 override_config_conv = UserConfig_clone(&override_config_conv);
28800 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
28801 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id_ref, override_config_conv);
28802 return tag_ptr(ret_conv, true);
28805 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_channels"))) TS_ChannelManager_list_channels(uint64_t this_arg) {
28806 LDKChannelManager this_arg_conv;
28807 this_arg_conv.inner = untag_ptr(this_arg);
28808 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28810 this_arg_conv.is_owned = false;
28811 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
28812 uint64_tArray ret_arr = NULL;
28813 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28814 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28815 for (size_t q = 0; q < ret_var.datalen; q++) {
28816 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28817 uint64_t ret_conv_16_ref = 0;
28818 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28819 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28820 ret_arr_ptr[q] = ret_conv_16_ref;
28823 FREE(ret_var.data);
28827 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_usable_channels"))) TS_ChannelManager_list_usable_channels(uint64_t this_arg) {
28828 LDKChannelManager this_arg_conv;
28829 this_arg_conv.inner = untag_ptr(this_arg);
28830 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28832 this_arg_conv.is_owned = false;
28833 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
28834 uint64_tArray ret_arr = NULL;
28835 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28836 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28837 for (size_t q = 0; q < ret_var.datalen; q++) {
28838 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28839 uint64_t ret_conv_16_ref = 0;
28840 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28841 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28842 ret_arr_ptr[q] = ret_conv_16_ref;
28845 FREE(ret_var.data);
28849 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) {
28850 LDKChannelManager this_arg_conv;
28851 this_arg_conv.inner = untag_ptr(this_arg);
28852 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28854 this_arg_conv.is_owned = false;
28855 LDKPublicKey counterparty_node_id_ref;
28856 CHECK(counterparty_node_id->arr_len == 33);
28857 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28858 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels_with_counterparty(&this_arg_conv, counterparty_node_id_ref);
28859 uint64_tArray ret_arr = NULL;
28860 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28861 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28862 for (size_t q = 0; q < ret_var.datalen; q++) {
28863 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
28864 uint64_t ret_conv_16_ref = 0;
28865 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
28866 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
28867 ret_arr_ptr[q] = ret_conv_16_ref;
28870 FREE(ret_var.data);
28874 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_recent_payments"))) TS_ChannelManager_list_recent_payments(uint64_t this_arg) {
28875 LDKChannelManager this_arg_conv;
28876 this_arg_conv.inner = untag_ptr(this_arg);
28877 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28879 this_arg_conv.is_owned = false;
28880 LDKCVec_RecentPaymentDetailsZ ret_var = ChannelManager_list_recent_payments(&this_arg_conv);
28881 uint64_tArray ret_arr = NULL;
28882 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
28883 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
28884 for (size_t w = 0; w < ret_var.datalen; w++) {
28885 LDKRecentPaymentDetails *ret_conv_22_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
28886 *ret_conv_22_copy = ret_var.data[w];
28887 uint64_t ret_conv_22_ref = tag_ptr(ret_conv_22_copy, true);
28888 ret_arr_ptr[w] = ret_conv_22_ref;
28891 FREE(ret_var.data);
28895 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) {
28896 LDKChannelManager this_arg_conv;
28897 this_arg_conv.inner = untag_ptr(this_arg);
28898 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28900 this_arg_conv.is_owned = false;
28901 uint8_t channel_id_arr[32];
28902 CHECK(channel_id->arr_len == 32);
28903 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28904 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28905 LDKPublicKey counterparty_node_id_ref;
28906 CHECK(counterparty_node_id->arr_len == 33);
28907 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28908 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28909 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28910 return tag_ptr(ret_conv, true);
28913 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) {
28914 LDKChannelManager this_arg_conv;
28915 this_arg_conv.inner = untag_ptr(this_arg);
28916 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28917 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28918 this_arg_conv.is_owned = false;
28919 uint8_t channel_id_arr[32];
28920 CHECK(channel_id->arr_len == 32);
28921 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28922 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28923 LDKPublicKey counterparty_node_id_ref;
28924 CHECK(counterparty_node_id->arr_len == 33);
28925 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28926 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28927 *ret_conv = ChannelManager_close_channel_with_target_feerate(&this_arg_conv, channel_id_ref, counterparty_node_id_ref, target_feerate_sats_per_1000_weight);
28928 return tag_ptr(ret_conv, true);
28931 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) {
28932 LDKChannelManager this_arg_conv;
28933 this_arg_conv.inner = untag_ptr(this_arg);
28934 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28936 this_arg_conv.is_owned = false;
28937 uint8_t channel_id_arr[32];
28938 CHECK(channel_id->arr_len == 32);
28939 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28940 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28941 LDKPublicKey counterparty_node_id_ref;
28942 CHECK(counterparty_node_id->arr_len == 33);
28943 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28944 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28945 *ret_conv = ChannelManager_force_close_broadcasting_latest_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28946 return tag_ptr(ret_conv, true);
28949 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) {
28950 LDKChannelManager this_arg_conv;
28951 this_arg_conv.inner = untag_ptr(this_arg);
28952 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28954 this_arg_conv.is_owned = false;
28955 uint8_t channel_id_arr[32];
28956 CHECK(channel_id->arr_len == 32);
28957 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
28958 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
28959 LDKPublicKey counterparty_node_id_ref;
28960 CHECK(counterparty_node_id->arr_len == 33);
28961 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
28962 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
28963 *ret_conv = ChannelManager_force_close_without_broadcasting_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
28964 return tag_ptr(ret_conv, true);
28967 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) {
28968 LDKChannelManager this_arg_conv;
28969 this_arg_conv.inner = untag_ptr(this_arg);
28970 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28972 this_arg_conv.is_owned = false;
28973 ChannelManager_force_close_all_channels_broadcasting_latest_txn(&this_arg_conv);
28976 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) {
28977 LDKChannelManager this_arg_conv;
28978 this_arg_conv.inner = untag_ptr(this_arg);
28979 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28980 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28981 this_arg_conv.is_owned = false;
28982 ChannelManager_force_close_all_channels_without_broadcasting_txn(&this_arg_conv);
28985 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) {
28986 LDKChannelManager this_arg_conv;
28987 this_arg_conv.inner = untag_ptr(this_arg);
28988 this_arg_conv.is_owned = ptr_is_owned(this_arg);
28989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
28990 this_arg_conv.is_owned = false;
28991 LDKRoute route_conv;
28992 route_conv.inner = untag_ptr(route);
28993 route_conv.is_owned = ptr_is_owned(route);
28994 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
28995 route_conv.is_owned = false;
28996 LDKThirtyTwoBytes payment_hash_ref;
28997 CHECK(payment_hash->arr_len == 32);
28998 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28999 LDKRecipientOnionFields recipient_onion_conv;
29000 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29001 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29002 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29003 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29004 LDKThirtyTwoBytes payment_id_ref;
29005 CHECK(payment_id->arr_len == 32);
29006 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29007 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
29008 *ret_conv = ChannelManager_send_payment_with_route(&this_arg_conv, &route_conv, payment_hash_ref, recipient_onion_conv, payment_id_ref);
29009 return tag_ptr(ret_conv, true);
29012 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) {
29013 LDKChannelManager this_arg_conv;
29014 this_arg_conv.inner = untag_ptr(this_arg);
29015 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29016 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29017 this_arg_conv.is_owned = false;
29018 LDKThirtyTwoBytes payment_hash_ref;
29019 CHECK(payment_hash->arr_len == 32);
29020 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29021 LDKRecipientOnionFields recipient_onion_conv;
29022 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29023 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29024 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29025 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29026 LDKThirtyTwoBytes payment_id_ref;
29027 CHECK(payment_id->arr_len == 32);
29028 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29029 LDKRouteParameters route_params_conv;
29030 route_params_conv.inner = untag_ptr(route_params);
29031 route_params_conv.is_owned = ptr_is_owned(route_params);
29032 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
29033 route_params_conv = RouteParameters_clone(&route_params_conv);
29034 void* retry_strategy_ptr = untag_ptr(retry_strategy);
29035 CHECK_ACCESS(retry_strategy_ptr);
29036 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
29037 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
29038 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
29039 *ret_conv = ChannelManager_send_payment(&this_arg_conv, payment_hash_ref, recipient_onion_conv, payment_id_ref, route_params_conv, retry_strategy_conv);
29040 return tag_ptr(ret_conv, true);
29043 void __attribute__((export_name("TS_ChannelManager_abandon_payment"))) TS_ChannelManager_abandon_payment(uint64_t this_arg, int8_tArray payment_id) {
29044 LDKChannelManager this_arg_conv;
29045 this_arg_conv.inner = untag_ptr(this_arg);
29046 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29047 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29048 this_arg_conv.is_owned = false;
29049 LDKThirtyTwoBytes payment_id_ref;
29050 CHECK(payment_id->arr_len == 32);
29051 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29052 ChannelManager_abandon_payment(&this_arg_conv, payment_id_ref);
29055 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) {
29056 LDKChannelManager this_arg_conv;
29057 this_arg_conv.inner = untag_ptr(this_arg);
29058 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29060 this_arg_conv.is_owned = false;
29061 LDKRoute route_conv;
29062 route_conv.inner = untag_ptr(route);
29063 route_conv.is_owned = ptr_is_owned(route);
29064 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
29065 route_conv.is_owned = false;
29066 LDKThirtyTwoBytes payment_preimage_ref;
29067 CHECK(payment_preimage->arr_len == 32);
29068 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
29069 LDKRecipientOnionFields recipient_onion_conv;
29070 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29071 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29072 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29073 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29074 LDKThirtyTwoBytes payment_id_ref;
29075 CHECK(payment_id->arr_len == 32);
29076 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29077 LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ");
29078 *ret_conv = ChannelManager_send_spontaneous_payment(&this_arg_conv, &route_conv, payment_preimage_ref, recipient_onion_conv, payment_id_ref);
29079 return tag_ptr(ret_conv, true);
29082 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) {
29083 LDKChannelManager this_arg_conv;
29084 this_arg_conv.inner = untag_ptr(this_arg);
29085 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29087 this_arg_conv.is_owned = false;
29088 LDKThirtyTwoBytes payment_preimage_ref;
29089 CHECK(payment_preimage->arr_len == 32);
29090 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
29091 LDKRecipientOnionFields recipient_onion_conv;
29092 recipient_onion_conv.inner = untag_ptr(recipient_onion);
29093 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
29094 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
29095 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
29096 LDKThirtyTwoBytes payment_id_ref;
29097 CHECK(payment_id->arr_len == 32);
29098 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
29099 LDKRouteParameters route_params_conv;
29100 route_params_conv.inner = untag_ptr(route_params);
29101 route_params_conv.is_owned = ptr_is_owned(route_params);
29102 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
29103 route_params_conv = RouteParameters_clone(&route_params_conv);
29104 void* retry_strategy_ptr = untag_ptr(retry_strategy);
29105 CHECK_ACCESS(retry_strategy_ptr);
29106 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
29107 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
29108 LDKCResult_PaymentHashRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashRetryableSendFailureZ), "LDKCResult_PaymentHashRetryableSendFailureZ");
29109 *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);
29110 return tag_ptr(ret_conv, true);
29113 uint64_t __attribute__((export_name("TS_ChannelManager_send_probe"))) TS_ChannelManager_send_probe(uint64_t this_arg, uint64_t path) {
29114 LDKChannelManager this_arg_conv;
29115 this_arg_conv.inner = untag_ptr(this_arg);
29116 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29118 this_arg_conv.is_owned = false;
29120 path_conv.inner = untag_ptr(path);
29121 path_conv.is_owned = ptr_is_owned(path);
29122 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
29123 path_conv = Path_clone(&path_conv);
29124 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
29125 *ret_conv = ChannelManager_send_probe(&this_arg_conv, path_conv);
29126 return tag_ptr(ret_conv, true);
29129 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) {
29130 LDKChannelManager this_arg_conv;
29131 this_arg_conv.inner = untag_ptr(this_arg);
29132 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29134 this_arg_conv.is_owned = false;
29135 uint8_t temporary_channel_id_arr[32];
29136 CHECK(temporary_channel_id->arr_len == 32);
29137 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
29138 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
29139 LDKPublicKey counterparty_node_id_ref;
29140 CHECK(counterparty_node_id->arr_len == 33);
29141 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29142 LDKTransaction funding_transaction_ref;
29143 funding_transaction_ref.datalen = funding_transaction->arr_len;
29144 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
29145 memcpy(funding_transaction_ref.data, funding_transaction->elems, funding_transaction_ref.datalen); FREE(funding_transaction);
29146 funding_transaction_ref.data_is_owned = true;
29147 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29148 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, funding_transaction_ref);
29149 return tag_ptr(ret_conv, true);
29152 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) {
29153 LDKChannelManager this_arg_conv;
29154 this_arg_conv.inner = untag_ptr(this_arg);
29155 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29156 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29157 this_arg_conv.is_owned = false;
29158 LDKPublicKey counterparty_node_id_ref;
29159 CHECK(counterparty_node_id->arr_len == 33);
29160 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29161 LDKCVec_ThirtyTwoBytesZ channel_ids_constr;
29162 channel_ids_constr.datalen = channel_ids->arr_len;
29163 if (channel_ids_constr.datalen > 0)
29164 channel_ids_constr.data = MALLOC(channel_ids_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
29166 channel_ids_constr.data = NULL;
29167 int8_tArray* channel_ids_vals = (void*) channel_ids->elems;
29168 for (size_t m = 0; m < channel_ids_constr.datalen; m++) {
29169 int8_tArray channel_ids_conv_12 = channel_ids_vals[m];
29170 LDKThirtyTwoBytes channel_ids_conv_12_ref;
29171 CHECK(channel_ids_conv_12->arr_len == 32);
29172 memcpy(channel_ids_conv_12_ref.data, channel_ids_conv_12->elems, 32); FREE(channel_ids_conv_12);
29173 channel_ids_constr.data[m] = channel_ids_conv_12_ref;
29176 LDKChannelConfig config_conv;
29177 config_conv.inner = untag_ptr(config);
29178 config_conv.is_owned = ptr_is_owned(config);
29179 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
29180 config_conv.is_owned = false;
29181 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29182 *ret_conv = ChannelManager_update_channel_config(&this_arg_conv, counterparty_node_id_ref, channel_ids_constr, &config_conv);
29183 return tag_ptr(ret_conv, true);
29186 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) {
29187 LDKChannelManager this_arg_conv;
29188 this_arg_conv.inner = untag_ptr(this_arg);
29189 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29191 this_arg_conv.is_owned = false;
29192 LDKThirtyTwoBytes intercept_id_ref;
29193 CHECK(intercept_id->arr_len == 32);
29194 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
29195 uint8_t next_hop_channel_id_arr[32];
29196 CHECK(next_hop_channel_id->arr_len == 32);
29197 memcpy(next_hop_channel_id_arr, next_hop_channel_id->elems, 32); FREE(next_hop_channel_id);
29198 uint8_t (*next_hop_channel_id_ref)[32] = &next_hop_channel_id_arr;
29199 LDKPublicKey next_node_id_ref;
29200 CHECK(next_node_id->arr_len == 33);
29201 memcpy(next_node_id_ref.compressed_form, next_node_id->elems, 33); FREE(next_node_id);
29202 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29203 *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);
29204 return tag_ptr(ret_conv, true);
29207 uint64_t __attribute__((export_name("TS_ChannelManager_fail_intercepted_htlc"))) TS_ChannelManager_fail_intercepted_htlc(uint64_t this_arg, int8_tArray intercept_id) {
29208 LDKChannelManager this_arg_conv;
29209 this_arg_conv.inner = untag_ptr(this_arg);
29210 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29212 this_arg_conv.is_owned = false;
29213 LDKThirtyTwoBytes intercept_id_ref;
29214 CHECK(intercept_id->arr_len == 32);
29215 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
29216 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29217 *ret_conv = ChannelManager_fail_intercepted_htlc(&this_arg_conv, intercept_id_ref);
29218 return tag_ptr(ret_conv, true);
29221 void __attribute__((export_name("TS_ChannelManager_process_pending_htlc_forwards"))) TS_ChannelManager_process_pending_htlc_forwards(uint64_t this_arg) {
29222 LDKChannelManager this_arg_conv;
29223 this_arg_conv.inner = untag_ptr(this_arg);
29224 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29226 this_arg_conv.is_owned = false;
29227 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
29230 void __attribute__((export_name("TS_ChannelManager_timer_tick_occurred"))) TS_ChannelManager_timer_tick_occurred(uint64_t this_arg) {
29231 LDKChannelManager this_arg_conv;
29232 this_arg_conv.inner = untag_ptr(this_arg);
29233 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29235 this_arg_conv.is_owned = false;
29236 ChannelManager_timer_tick_occurred(&this_arg_conv);
29239 void __attribute__((export_name("TS_ChannelManager_fail_htlc_backwards"))) TS_ChannelManager_fail_htlc_backwards(uint64_t this_arg, int8_tArray payment_hash) {
29240 LDKChannelManager this_arg_conv;
29241 this_arg_conv.inner = untag_ptr(this_arg);
29242 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29244 this_arg_conv.is_owned = false;
29245 uint8_t payment_hash_arr[32];
29246 CHECK(payment_hash->arr_len == 32);
29247 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
29248 uint8_t (*payment_hash_ref)[32] = &payment_hash_arr;
29249 ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
29252 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) {
29253 LDKChannelManager this_arg_conv;
29254 this_arg_conv.inner = untag_ptr(this_arg);
29255 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29257 this_arg_conv.is_owned = false;
29258 uint8_t payment_hash_arr[32];
29259 CHECK(payment_hash->arr_len == 32);
29260 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
29261 uint8_t (*payment_hash_ref)[32] = &payment_hash_arr;
29262 LDKFailureCode failure_code_conv = LDKFailureCode_from_js(failure_code);
29263 ChannelManager_fail_htlc_backwards_with_reason(&this_arg_conv, payment_hash_ref, failure_code_conv);
29266 void __attribute__((export_name("TS_ChannelManager_claim_funds"))) TS_ChannelManager_claim_funds(uint64_t this_arg, int8_tArray payment_preimage) {
29267 LDKChannelManager this_arg_conv;
29268 this_arg_conv.inner = untag_ptr(this_arg);
29269 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29271 this_arg_conv.is_owned = false;
29272 LDKThirtyTwoBytes payment_preimage_ref;
29273 CHECK(payment_preimage->arr_len == 32);
29274 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
29275 ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
29278 int8_tArray __attribute__((export_name("TS_ChannelManager_get_our_node_id"))) TS_ChannelManager_get_our_node_id(uint64_t this_arg) {
29279 LDKChannelManager this_arg_conv;
29280 this_arg_conv.inner = untag_ptr(this_arg);
29281 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29282 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29283 this_arg_conv.is_owned = false;
29284 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29285 memcpy(ret_arr->elems, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
29289 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) {
29290 LDKChannelManager this_arg_conv;
29291 this_arg_conv.inner = untag_ptr(this_arg);
29292 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29294 this_arg_conv.is_owned = false;
29295 uint8_t temporary_channel_id_arr[32];
29296 CHECK(temporary_channel_id->arr_len == 32);
29297 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
29298 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
29299 LDKPublicKey counterparty_node_id_ref;
29300 CHECK(counterparty_node_id->arr_len == 33);
29301 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29302 LDKU128 user_channel_id_ref;
29303 CHECK(user_channel_id->arr_len == 16);
29304 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
29305 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29306 *ret_conv = ChannelManager_accept_inbound_channel(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id_ref);
29307 return tag_ptr(ret_conv, true);
29310 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) {
29311 LDKChannelManager this_arg_conv;
29312 this_arg_conv.inner = untag_ptr(this_arg);
29313 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29314 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29315 this_arg_conv.is_owned = false;
29316 uint8_t temporary_channel_id_arr[32];
29317 CHECK(temporary_channel_id->arr_len == 32);
29318 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
29319 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
29320 LDKPublicKey counterparty_node_id_ref;
29321 CHECK(counterparty_node_id->arr_len == 33);
29322 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
29323 LDKU128 user_channel_id_ref;
29324 CHECK(user_channel_id->arr_len == 16);
29325 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
29326 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
29327 *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);
29328 return tag_ptr(ret_conv, true);
29331 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) {
29332 LDKChannelManager this_arg_conv;
29333 this_arg_conv.inner = untag_ptr(this_arg);
29334 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29336 this_arg_conv.is_owned = false;
29337 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29338 CHECK_ACCESS(min_value_msat_ptr);
29339 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29340 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29341 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
29342 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
29343 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
29344 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
29345 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
29346 *ret_conv = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, min_final_cltv_expiry_delta_conv);
29347 return tag_ptr(ret_conv, true);
29350 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) {
29351 LDKChannelManager this_arg_conv;
29352 this_arg_conv.inner = untag_ptr(this_arg);
29353 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29354 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29355 this_arg_conv.is_owned = false;
29356 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29357 CHECK_ACCESS(min_value_msat_ptr);
29358 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29359 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29360 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
29361 *ret_conv = ChannelManager_create_inbound_payment_legacy(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs);
29362 return tag_ptr(ret_conv, true);
29365 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) {
29366 LDKChannelManager this_arg_conv;
29367 this_arg_conv.inner = untag_ptr(this_arg);
29368 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29369 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29370 this_arg_conv.is_owned = false;
29371 LDKThirtyTwoBytes payment_hash_ref;
29372 CHECK(payment_hash->arr_len == 32);
29373 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29374 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29375 CHECK_ACCESS(min_value_msat_ptr);
29376 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29377 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29378 void* min_final_cltv_expiry_ptr = untag_ptr(min_final_cltv_expiry);
29379 CHECK_ACCESS(min_final_cltv_expiry_ptr);
29380 LDKCOption_u16Z min_final_cltv_expiry_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_ptr);
29381 min_final_cltv_expiry_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry));
29382 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
29383 *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);
29384 return tag_ptr(ret_conv, true);
29387 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) {
29388 LDKChannelManager this_arg_conv;
29389 this_arg_conv.inner = untag_ptr(this_arg);
29390 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29391 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29392 this_arg_conv.is_owned = false;
29393 LDKThirtyTwoBytes payment_hash_ref;
29394 CHECK(payment_hash->arr_len == 32);
29395 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29396 void* min_value_msat_ptr = untag_ptr(min_value_msat);
29397 CHECK_ACCESS(min_value_msat_ptr);
29398 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
29399 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
29400 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
29401 *ret_conv = ChannelManager_create_inbound_payment_for_hash_legacy(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs);
29402 return tag_ptr(ret_conv, true);
29405 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) {
29406 LDKChannelManager this_arg_conv;
29407 this_arg_conv.inner = untag_ptr(this_arg);
29408 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29410 this_arg_conv.is_owned = false;
29411 LDKThirtyTwoBytes payment_hash_ref;
29412 CHECK(payment_hash->arr_len == 32);
29413 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
29414 LDKThirtyTwoBytes payment_secret_ref;
29415 CHECK(payment_secret->arr_len == 32);
29416 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
29417 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
29418 *ret_conv = ChannelManager_get_payment_preimage(&this_arg_conv, payment_hash_ref, payment_secret_ref);
29419 return tag_ptr(ret_conv, true);
29422 int64_t __attribute__((export_name("TS_ChannelManager_get_phantom_scid"))) TS_ChannelManager_get_phantom_scid(uint64_t this_arg) {
29423 LDKChannelManager this_arg_conv;
29424 this_arg_conv.inner = untag_ptr(this_arg);
29425 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29427 this_arg_conv.is_owned = false;
29428 int64_t ret_conv = ChannelManager_get_phantom_scid(&this_arg_conv);
29432 uint64_t __attribute__((export_name("TS_ChannelManager_get_phantom_route_hints"))) TS_ChannelManager_get_phantom_route_hints(uint64_t this_arg) {
29433 LDKChannelManager this_arg_conv;
29434 this_arg_conv.inner = untag_ptr(this_arg);
29435 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29436 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29437 this_arg_conv.is_owned = false;
29438 LDKPhantomRouteHints ret_var = ChannelManager_get_phantom_route_hints(&this_arg_conv);
29439 uint64_t ret_ref = 0;
29440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29441 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29445 int64_t __attribute__((export_name("TS_ChannelManager_get_intercept_scid"))) TS_ChannelManager_get_intercept_scid(uint64_t this_arg) {
29446 LDKChannelManager this_arg_conv;
29447 this_arg_conv.inner = untag_ptr(this_arg);
29448 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29450 this_arg_conv.is_owned = false;
29451 int64_t ret_conv = ChannelManager_get_intercept_scid(&this_arg_conv);
29455 uint64_t __attribute__((export_name("TS_ChannelManager_compute_inflight_htlcs"))) TS_ChannelManager_compute_inflight_htlcs(uint64_t this_arg) {
29456 LDKChannelManager this_arg_conv;
29457 this_arg_conv.inner = untag_ptr(this_arg);
29458 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29460 this_arg_conv.is_owned = false;
29461 LDKInFlightHtlcs ret_var = ChannelManager_compute_inflight_htlcs(&this_arg_conv);
29462 uint64_t ret_ref = 0;
29463 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29464 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29468 uint64_t __attribute__((export_name("TS_ChannelManager_as_MessageSendEventsProvider"))) TS_ChannelManager_as_MessageSendEventsProvider(uint64_t this_arg) {
29469 LDKChannelManager this_arg_conv;
29470 this_arg_conv.inner = untag_ptr(this_arg);
29471 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29472 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29473 this_arg_conv.is_owned = false;
29474 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
29475 *ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
29476 return tag_ptr(ret_ret, true);
29479 uint64_t __attribute__((export_name("TS_ChannelManager_as_EventsProvider"))) TS_ChannelManager_as_EventsProvider(uint64_t this_arg) {
29480 LDKChannelManager this_arg_conv;
29481 this_arg_conv.inner = untag_ptr(this_arg);
29482 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29484 this_arg_conv.is_owned = false;
29485 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
29486 *ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
29487 return tag_ptr(ret_ret, true);
29490 uint64_t __attribute__((export_name("TS_ChannelManager_as_Listen"))) TS_ChannelManager_as_Listen(uint64_t this_arg) {
29491 LDKChannelManager this_arg_conv;
29492 this_arg_conv.inner = untag_ptr(this_arg);
29493 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29495 this_arg_conv.is_owned = false;
29496 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
29497 *ret_ret = ChannelManager_as_Listen(&this_arg_conv);
29498 return tag_ptr(ret_ret, true);
29501 uint64_t __attribute__((export_name("TS_ChannelManager_as_Confirm"))) TS_ChannelManager_as_Confirm(uint64_t this_arg) {
29502 LDKChannelManager this_arg_conv;
29503 this_arg_conv.inner = untag_ptr(this_arg);
29504 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29506 this_arg_conv.is_owned = false;
29507 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
29508 *ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
29509 return tag_ptr(ret_ret, true);
29512 uint64_t __attribute__((export_name("TS_ChannelManager_get_persistable_update_future"))) TS_ChannelManager_get_persistable_update_future(uint64_t this_arg) {
29513 LDKChannelManager this_arg_conv;
29514 this_arg_conv.inner = untag_ptr(this_arg);
29515 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29516 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29517 this_arg_conv.is_owned = false;
29518 LDKFuture ret_var = ChannelManager_get_persistable_update_future(&this_arg_conv);
29519 uint64_t ret_ref = 0;
29520 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29521 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29525 uint64_t __attribute__((export_name("TS_ChannelManager_current_best_block"))) TS_ChannelManager_current_best_block(uint64_t this_arg) {
29526 LDKChannelManager this_arg_conv;
29527 this_arg_conv.inner = untag_ptr(this_arg);
29528 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29529 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29530 this_arg_conv.is_owned = false;
29531 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
29532 uint64_t ret_ref = 0;
29533 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29534 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29538 uint64_t __attribute__((export_name("TS_ChannelManager_node_features"))) TS_ChannelManager_node_features(uint64_t this_arg) {
29539 LDKChannelManager this_arg_conv;
29540 this_arg_conv.inner = untag_ptr(this_arg);
29541 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29542 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29543 this_arg_conv.is_owned = false;
29544 LDKNodeFeatures ret_var = ChannelManager_node_features(&this_arg_conv);
29545 uint64_t ret_ref = 0;
29546 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29547 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29551 uint64_t __attribute__((export_name("TS_ChannelManager_channel_features"))) TS_ChannelManager_channel_features(uint64_t this_arg) {
29552 LDKChannelManager this_arg_conv;
29553 this_arg_conv.inner = untag_ptr(this_arg);
29554 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29556 this_arg_conv.is_owned = false;
29557 LDKChannelFeatures ret_var = ChannelManager_channel_features(&this_arg_conv);
29558 uint64_t ret_ref = 0;
29559 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29560 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29564 uint64_t __attribute__((export_name("TS_ChannelManager_channel_type_features"))) TS_ChannelManager_channel_type_features(uint64_t this_arg) {
29565 LDKChannelManager this_arg_conv;
29566 this_arg_conv.inner = untag_ptr(this_arg);
29567 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29569 this_arg_conv.is_owned = false;
29570 LDKChannelTypeFeatures ret_var = ChannelManager_channel_type_features(&this_arg_conv);
29571 uint64_t ret_ref = 0;
29572 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29573 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29577 uint64_t __attribute__((export_name("TS_ChannelManager_init_features"))) TS_ChannelManager_init_features(uint64_t this_arg) {
29578 LDKChannelManager this_arg_conv;
29579 this_arg_conv.inner = untag_ptr(this_arg);
29580 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29582 this_arg_conv.is_owned = false;
29583 LDKInitFeatures ret_var = ChannelManager_init_features(&this_arg_conv);
29584 uint64_t ret_ref = 0;
29585 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29586 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29590 uint64_t __attribute__((export_name("TS_ChannelManager_as_ChannelMessageHandler"))) TS_ChannelManager_as_ChannelMessageHandler(uint64_t this_arg) {
29591 LDKChannelManager this_arg_conv;
29592 this_arg_conv.inner = untag_ptr(this_arg);
29593 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29595 this_arg_conv.is_owned = false;
29596 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
29597 *ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
29598 return tag_ptr(ret_ret, true);
29601 uint64_t __attribute__((export_name("TS_provided_init_features"))) TS_provided_init_features(uint64_t _config) {
29602 LDKUserConfig _config_conv;
29603 _config_conv.inner = untag_ptr(_config);
29604 _config_conv.is_owned = ptr_is_owned(_config);
29605 CHECK_INNER_FIELD_ACCESS_OR_NULL(_config_conv);
29606 _config_conv.is_owned = false;
29607 LDKInitFeatures ret_var = provided_init_features(&_config_conv);
29608 uint64_t ret_ref = 0;
29609 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29610 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29614 int8_tArray __attribute__((export_name("TS_CounterpartyForwardingInfo_write"))) TS_CounterpartyForwardingInfo_write(uint64_t obj) {
29615 LDKCounterpartyForwardingInfo obj_conv;
29616 obj_conv.inner = untag_ptr(obj);
29617 obj_conv.is_owned = ptr_is_owned(obj);
29618 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29619 obj_conv.is_owned = false;
29620 LDKCVec_u8Z ret_var = CounterpartyForwardingInfo_write(&obj_conv);
29621 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29622 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29623 CVec_u8Z_free(ret_var);
29627 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_read"))) TS_CounterpartyForwardingInfo_read(int8_tArray ser) {
29628 LDKu8slice ser_ref;
29629 ser_ref.datalen = ser->arr_len;
29630 ser_ref.data = ser->elems;
29631 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
29632 *ret_conv = CounterpartyForwardingInfo_read(ser_ref);
29634 return tag_ptr(ret_conv, true);
29637 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_write"))) TS_ChannelCounterparty_write(uint64_t obj) {
29638 LDKChannelCounterparty obj_conv;
29639 obj_conv.inner = untag_ptr(obj);
29640 obj_conv.is_owned = ptr_is_owned(obj);
29641 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29642 obj_conv.is_owned = false;
29643 LDKCVec_u8Z ret_var = ChannelCounterparty_write(&obj_conv);
29644 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29645 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29646 CVec_u8Z_free(ret_var);
29650 uint64_t __attribute__((export_name("TS_ChannelCounterparty_read"))) TS_ChannelCounterparty_read(int8_tArray ser) {
29651 LDKu8slice ser_ref;
29652 ser_ref.datalen = ser->arr_len;
29653 ser_ref.data = ser->elems;
29654 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
29655 *ret_conv = ChannelCounterparty_read(ser_ref);
29657 return tag_ptr(ret_conv, true);
29660 int8_tArray __attribute__((export_name("TS_ChannelDetails_write"))) TS_ChannelDetails_write(uint64_t obj) {
29661 LDKChannelDetails obj_conv;
29662 obj_conv.inner = untag_ptr(obj);
29663 obj_conv.is_owned = ptr_is_owned(obj);
29664 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29665 obj_conv.is_owned = false;
29666 LDKCVec_u8Z ret_var = ChannelDetails_write(&obj_conv);
29667 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29668 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29669 CVec_u8Z_free(ret_var);
29673 uint64_t __attribute__((export_name("TS_ChannelDetails_read"))) TS_ChannelDetails_read(int8_tArray ser) {
29674 LDKu8slice ser_ref;
29675 ser_ref.datalen = ser->arr_len;
29676 ser_ref.data = ser->elems;
29677 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
29678 *ret_conv = ChannelDetails_read(ser_ref);
29680 return tag_ptr(ret_conv, true);
29683 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_write"))) TS_PhantomRouteHints_write(uint64_t obj) {
29684 LDKPhantomRouteHints obj_conv;
29685 obj_conv.inner = untag_ptr(obj);
29686 obj_conv.is_owned = ptr_is_owned(obj);
29687 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29688 obj_conv.is_owned = false;
29689 LDKCVec_u8Z ret_var = PhantomRouteHints_write(&obj_conv);
29690 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29691 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29692 CVec_u8Z_free(ret_var);
29696 uint64_t __attribute__((export_name("TS_PhantomRouteHints_read"))) TS_PhantomRouteHints_read(int8_tArray ser) {
29697 LDKu8slice ser_ref;
29698 ser_ref.datalen = ser->arr_len;
29699 ser_ref.data = ser->elems;
29700 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
29701 *ret_conv = PhantomRouteHints_read(ser_ref);
29703 return tag_ptr(ret_conv, true);
29706 int8_tArray __attribute__((export_name("TS_ChannelManager_write"))) TS_ChannelManager_write(uint64_t obj) {
29707 LDKChannelManager obj_conv;
29708 obj_conv.inner = untag_ptr(obj);
29709 obj_conv.is_owned = ptr_is_owned(obj);
29710 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29711 obj_conv.is_owned = false;
29712 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
29713 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29714 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29715 CVec_u8Z_free(ret_var);
29719 void __attribute__((export_name("TS_ChannelManagerReadArgs_free"))) TS_ChannelManagerReadArgs_free(uint64_t this_obj) {
29720 LDKChannelManagerReadArgs this_obj_conv;
29721 this_obj_conv.inner = untag_ptr(this_obj);
29722 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29724 ChannelManagerReadArgs_free(this_obj_conv);
29727 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_entropy_source"))) TS_ChannelManagerReadArgs_get_entropy_source(uint64_t this_ptr) {
29728 LDKChannelManagerReadArgs this_ptr_conv;
29729 this_ptr_conv.inner = untag_ptr(this_ptr);
29730 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29732 this_ptr_conv.is_owned = false;
29733 // WARNING: This object doesn't live past this scope, needs clone!
29734 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_entropy_source(&this_ptr_conv), false);
29738 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_entropy_source"))) TS_ChannelManagerReadArgs_set_entropy_source(uint64_t this_ptr, uint64_t val) {
29739 LDKChannelManagerReadArgs this_ptr_conv;
29740 this_ptr_conv.inner = untag_ptr(this_ptr);
29741 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29742 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29743 this_ptr_conv.is_owned = false;
29744 void* val_ptr = untag_ptr(val);
29745 CHECK_ACCESS(val_ptr);
29746 LDKEntropySource val_conv = *(LDKEntropySource*)(val_ptr);
29747 if (val_conv.free == LDKEntropySource_JCalls_free) {
29748 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29749 LDKEntropySource_JCalls_cloned(&val_conv);
29751 ChannelManagerReadArgs_set_entropy_source(&this_ptr_conv, val_conv);
29754 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_node_signer"))) TS_ChannelManagerReadArgs_get_node_signer(uint64_t this_ptr) {
29755 LDKChannelManagerReadArgs this_ptr_conv;
29756 this_ptr_conv.inner = untag_ptr(this_ptr);
29757 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29758 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29759 this_ptr_conv.is_owned = false;
29760 // WARNING: This object doesn't live past this scope, needs clone!
29761 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_node_signer(&this_ptr_conv), false);
29765 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_node_signer"))) TS_ChannelManagerReadArgs_set_node_signer(uint64_t this_ptr, uint64_t val) {
29766 LDKChannelManagerReadArgs this_ptr_conv;
29767 this_ptr_conv.inner = untag_ptr(this_ptr);
29768 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29770 this_ptr_conv.is_owned = false;
29771 void* val_ptr = untag_ptr(val);
29772 CHECK_ACCESS(val_ptr);
29773 LDKNodeSigner val_conv = *(LDKNodeSigner*)(val_ptr);
29774 if (val_conv.free == LDKNodeSigner_JCalls_free) {
29775 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29776 LDKNodeSigner_JCalls_cloned(&val_conv);
29778 ChannelManagerReadArgs_set_node_signer(&this_ptr_conv, val_conv);
29781 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_signer_provider"))) TS_ChannelManagerReadArgs_get_signer_provider(uint64_t this_ptr) {
29782 LDKChannelManagerReadArgs this_ptr_conv;
29783 this_ptr_conv.inner = untag_ptr(this_ptr);
29784 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29785 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29786 this_ptr_conv.is_owned = false;
29787 // WARNING: This object doesn't live past this scope, needs clone!
29788 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_signer_provider(&this_ptr_conv), false);
29792 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_signer_provider"))) TS_ChannelManagerReadArgs_set_signer_provider(uint64_t this_ptr, uint64_t val) {
29793 LDKChannelManagerReadArgs this_ptr_conv;
29794 this_ptr_conv.inner = untag_ptr(this_ptr);
29795 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29796 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29797 this_ptr_conv.is_owned = false;
29798 void* val_ptr = untag_ptr(val);
29799 CHECK_ACCESS(val_ptr);
29800 LDKSignerProvider val_conv = *(LDKSignerProvider*)(val_ptr);
29801 if (val_conv.free == LDKSignerProvider_JCalls_free) {
29802 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29803 LDKSignerProvider_JCalls_cloned(&val_conv);
29805 ChannelManagerReadArgs_set_signer_provider(&this_ptr_conv, val_conv);
29808 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_fee_estimator"))) TS_ChannelManagerReadArgs_get_fee_estimator(uint64_t this_ptr) {
29809 LDKChannelManagerReadArgs this_ptr_conv;
29810 this_ptr_conv.inner = untag_ptr(this_ptr);
29811 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29812 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29813 this_ptr_conv.is_owned = false;
29814 // WARNING: This object doesn't live past this scope, needs clone!
29815 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv), false);
29819 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_fee_estimator"))) TS_ChannelManagerReadArgs_set_fee_estimator(uint64_t this_ptr, uint64_t val) {
29820 LDKChannelManagerReadArgs this_ptr_conv;
29821 this_ptr_conv.inner = untag_ptr(this_ptr);
29822 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29824 this_ptr_conv.is_owned = false;
29825 void* val_ptr = untag_ptr(val);
29826 CHECK_ACCESS(val_ptr);
29827 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
29828 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
29829 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29830 LDKFeeEstimator_JCalls_cloned(&val_conv);
29832 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
29835 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_chain_monitor"))) TS_ChannelManagerReadArgs_get_chain_monitor(uint64_t this_ptr) {
29836 LDKChannelManagerReadArgs this_ptr_conv;
29837 this_ptr_conv.inner = untag_ptr(this_ptr);
29838 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29840 this_ptr_conv.is_owned = false;
29841 // WARNING: This object doesn't live past this scope, needs clone!
29842 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv), false);
29846 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_chain_monitor"))) TS_ChannelManagerReadArgs_set_chain_monitor(uint64_t this_ptr, uint64_t val) {
29847 LDKChannelManagerReadArgs this_ptr_conv;
29848 this_ptr_conv.inner = untag_ptr(this_ptr);
29849 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29850 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29851 this_ptr_conv.is_owned = false;
29852 void* val_ptr = untag_ptr(val);
29853 CHECK_ACCESS(val_ptr);
29854 LDKWatch val_conv = *(LDKWatch*)(val_ptr);
29855 if (val_conv.free == LDKWatch_JCalls_free) {
29856 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29857 LDKWatch_JCalls_cloned(&val_conv);
29859 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
29862 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_tx_broadcaster"))) TS_ChannelManagerReadArgs_get_tx_broadcaster(uint64_t this_ptr) {
29863 LDKChannelManagerReadArgs this_ptr_conv;
29864 this_ptr_conv.inner = untag_ptr(this_ptr);
29865 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29867 this_ptr_conv.is_owned = false;
29868 // WARNING: This object doesn't live past this scope, needs clone!
29869 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv), false);
29873 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_tx_broadcaster"))) TS_ChannelManagerReadArgs_set_tx_broadcaster(uint64_t this_ptr, uint64_t val) {
29874 LDKChannelManagerReadArgs this_ptr_conv;
29875 this_ptr_conv.inner = untag_ptr(this_ptr);
29876 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29878 this_ptr_conv.is_owned = false;
29879 void* val_ptr = untag_ptr(val);
29880 CHECK_ACCESS(val_ptr);
29881 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
29882 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
29883 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29884 LDKBroadcasterInterface_JCalls_cloned(&val_conv);
29886 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
29889 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_router"))) TS_ChannelManagerReadArgs_get_router(uint64_t this_ptr) {
29890 LDKChannelManagerReadArgs this_ptr_conv;
29891 this_ptr_conv.inner = untag_ptr(this_ptr);
29892 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29893 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29894 this_ptr_conv.is_owned = false;
29895 // WARNING: This object doesn't live past this scope, needs clone!
29896 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_router(&this_ptr_conv), false);
29900 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_router"))) TS_ChannelManagerReadArgs_set_router(uint64_t this_ptr, uint64_t val) {
29901 LDKChannelManagerReadArgs this_ptr_conv;
29902 this_ptr_conv.inner = untag_ptr(this_ptr);
29903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29905 this_ptr_conv.is_owned = false;
29906 void* val_ptr = untag_ptr(val);
29907 CHECK_ACCESS(val_ptr);
29908 LDKRouter val_conv = *(LDKRouter*)(val_ptr);
29909 if (val_conv.free == LDKRouter_JCalls_free) {
29910 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29911 LDKRouter_JCalls_cloned(&val_conv);
29913 ChannelManagerReadArgs_set_router(&this_ptr_conv, val_conv);
29916 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_logger"))) TS_ChannelManagerReadArgs_get_logger(uint64_t this_ptr) {
29917 LDKChannelManagerReadArgs this_ptr_conv;
29918 this_ptr_conv.inner = untag_ptr(this_ptr);
29919 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29921 this_ptr_conv.is_owned = false;
29922 // WARNING: This object doesn't live past this scope, needs clone!
29923 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_logger(&this_ptr_conv), false);
29927 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_logger"))) TS_ChannelManagerReadArgs_set_logger(uint64_t this_ptr, uint64_t val) {
29928 LDKChannelManagerReadArgs this_ptr_conv;
29929 this_ptr_conv.inner = untag_ptr(this_ptr);
29930 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29932 this_ptr_conv.is_owned = false;
29933 void* val_ptr = untag_ptr(val);
29934 CHECK_ACCESS(val_ptr);
29935 LDKLogger val_conv = *(LDKLogger*)(val_ptr);
29936 if (val_conv.free == LDKLogger_JCalls_free) {
29937 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29938 LDKLogger_JCalls_cloned(&val_conv);
29940 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
29943 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_default_config"))) TS_ChannelManagerReadArgs_get_default_config(uint64_t this_ptr) {
29944 LDKChannelManagerReadArgs this_ptr_conv;
29945 this_ptr_conv.inner = untag_ptr(this_ptr);
29946 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29948 this_ptr_conv.is_owned = false;
29949 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
29950 uint64_t ret_ref = 0;
29951 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29952 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29956 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_default_config"))) TS_ChannelManagerReadArgs_set_default_config(uint64_t this_ptr, uint64_t val) {
29957 LDKChannelManagerReadArgs this_ptr_conv;
29958 this_ptr_conv.inner = untag_ptr(this_ptr);
29959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29961 this_ptr_conv.is_owned = false;
29962 LDKUserConfig val_conv;
29963 val_conv.inner = untag_ptr(val);
29964 val_conv.is_owned = ptr_is_owned(val);
29965 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
29966 val_conv = UserConfig_clone(&val_conv);
29967 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
29970 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) {
29971 void* entropy_source_ptr = untag_ptr(entropy_source);
29972 CHECK_ACCESS(entropy_source_ptr);
29973 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
29974 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
29975 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29976 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
29978 void* node_signer_ptr = untag_ptr(node_signer);
29979 CHECK_ACCESS(node_signer_ptr);
29980 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
29981 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
29982 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29983 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
29985 void* signer_provider_ptr = untag_ptr(signer_provider);
29986 CHECK_ACCESS(signer_provider_ptr);
29987 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
29988 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
29989 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29990 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
29992 void* fee_estimator_ptr = untag_ptr(fee_estimator);
29993 CHECK_ACCESS(fee_estimator_ptr);
29994 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
29995 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
29996 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29997 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
29999 void* chain_monitor_ptr = untag_ptr(chain_monitor);
30000 CHECK_ACCESS(chain_monitor_ptr);
30001 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
30002 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
30003 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30004 LDKWatch_JCalls_cloned(&chain_monitor_conv);
30006 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
30007 CHECK_ACCESS(tx_broadcaster_ptr);
30008 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
30009 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
30010 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30011 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
30013 void* router_ptr = untag_ptr(router);
30014 CHECK_ACCESS(router_ptr);
30015 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
30016 if (router_conv.free == LDKRouter_JCalls_free) {
30017 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30018 LDKRouter_JCalls_cloned(&router_conv);
30020 void* logger_ptr = untag_ptr(logger);
30021 CHECK_ACCESS(logger_ptr);
30022 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
30023 if (logger_conv.free == LDKLogger_JCalls_free) {
30024 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
30025 LDKLogger_JCalls_cloned(&logger_conv);
30027 LDKUserConfig default_config_conv;
30028 default_config_conv.inner = untag_ptr(default_config);
30029 default_config_conv.is_owned = ptr_is_owned(default_config);
30030 CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
30031 default_config_conv = UserConfig_clone(&default_config_conv);
30032 LDKCVec_ChannelMonitorZ channel_monitors_constr;
30033 channel_monitors_constr.datalen = channel_monitors->arr_len;
30034 if (channel_monitors_constr.datalen > 0)
30035 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
30037 channel_monitors_constr.data = NULL;
30038 uint64_t* channel_monitors_vals = channel_monitors->elems;
30039 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
30040 uint64_t channel_monitors_conv_16 = channel_monitors_vals[q];
30041 LDKChannelMonitor channel_monitors_conv_16_conv;
30042 channel_monitors_conv_16_conv.inner = untag_ptr(channel_monitors_conv_16);
30043 channel_monitors_conv_16_conv.is_owned = ptr_is_owned(channel_monitors_conv_16);
30044 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
30045 channel_monitors_conv_16_conv.is_owned = false;
30046 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
30048 FREE(channel_monitors);
30049 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);
30050 uint64_t ret_ref = 0;
30051 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30052 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30056 uint64_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_read"))) TS_C2Tuple_BlockHashChannelManagerZ_read(int8_tArray ser, uint64_t arg) {
30057 LDKu8slice ser_ref;
30058 ser_ref.datalen = ser->arr_len;
30059 ser_ref.data = ser->elems;
30060 LDKChannelManagerReadArgs arg_conv;
30061 arg_conv.inner = untag_ptr(arg);
30062 arg_conv.is_owned = ptr_is_owned(arg);
30063 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30064 // WARNING: we need a move here but no clone is available for LDKChannelManagerReadArgs
30066 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
30067 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
30069 return tag_ptr(ret_conv, true);
30072 void __attribute__((export_name("TS_ExpandedKey_free"))) TS_ExpandedKey_free(uint64_t this_obj) {
30073 LDKExpandedKey this_obj_conv;
30074 this_obj_conv.inner = untag_ptr(this_obj);
30075 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30077 ExpandedKey_free(this_obj_conv);
30080 uint64_t __attribute__((export_name("TS_ExpandedKey_new"))) TS_ExpandedKey_new(int8_tArray key_material) {
30081 uint8_t key_material_arr[32];
30082 CHECK(key_material->arr_len == 32);
30083 memcpy(key_material_arr, key_material->elems, 32); FREE(key_material);
30084 uint8_t (*key_material_ref)[32] = &key_material_arr;
30085 LDKExpandedKey ret_var = ExpandedKey_new(key_material_ref);
30086 uint64_t ret_ref = 0;
30087 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30088 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30092 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) {
30093 LDKExpandedKey keys_conv;
30094 keys_conv.inner = untag_ptr(keys);
30095 keys_conv.is_owned = ptr_is_owned(keys);
30096 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
30097 keys_conv.is_owned = false;
30098 void* min_value_msat_ptr = untag_ptr(min_value_msat);
30099 CHECK_ACCESS(min_value_msat_ptr);
30100 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
30101 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
30102 void* entropy_source_ptr = untag_ptr(entropy_source);
30103 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
30104 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
30105 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
30106 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
30107 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
30108 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
30109 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
30110 *ret_conv = create(&keys_conv, min_value_msat_conv, invoice_expiry_delta_secs, entropy_source_conv, current_time, min_final_cltv_expiry_delta_conv);
30111 return tag_ptr(ret_conv, true);
30114 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) {
30115 LDKExpandedKey keys_conv;
30116 keys_conv.inner = untag_ptr(keys);
30117 keys_conv.is_owned = ptr_is_owned(keys);
30118 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
30119 keys_conv.is_owned = false;
30120 void* min_value_msat_ptr = untag_ptr(min_value_msat);
30121 CHECK_ACCESS(min_value_msat_ptr);
30122 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
30123 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
30124 LDKThirtyTwoBytes payment_hash_ref;
30125 CHECK(payment_hash->arr_len == 32);
30126 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
30127 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
30128 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
30129 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
30130 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
30131 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
30132 *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);
30133 return tag_ptr(ret_conv, true);
30136 void __attribute__((export_name("TS_DecodeError_free"))) TS_DecodeError_free(uint64_t this_ptr) {
30137 if (!ptr_is_owned(this_ptr)) return;
30138 void* this_ptr_ptr = untag_ptr(this_ptr);
30139 CHECK_ACCESS(this_ptr_ptr);
30140 LDKDecodeError this_ptr_conv = *(LDKDecodeError*)(this_ptr_ptr);
30141 FREE(untag_ptr(this_ptr));
30142 DecodeError_free(this_ptr_conv);
30145 static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
30146 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30147 *ret_copy = DecodeError_clone(arg);
30148 uint64_t ret_ref = tag_ptr(ret_copy, true);
30151 int64_t __attribute__((export_name("TS_DecodeError_clone_ptr"))) TS_DecodeError_clone_ptr(uint64_t arg) {
30152 LDKDecodeError* arg_conv = (LDKDecodeError*)untag_ptr(arg);
30153 int64_t ret_conv = DecodeError_clone_ptr(arg_conv);
30157 uint64_t __attribute__((export_name("TS_DecodeError_clone"))) TS_DecodeError_clone(uint64_t orig) {
30158 LDKDecodeError* orig_conv = (LDKDecodeError*)untag_ptr(orig);
30159 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30160 *ret_copy = DecodeError_clone(orig_conv);
30161 uint64_t ret_ref = tag_ptr(ret_copy, true);
30165 uint64_t __attribute__((export_name("TS_DecodeError_unknown_version"))) TS_DecodeError_unknown_version() {
30166 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30167 *ret_copy = DecodeError_unknown_version();
30168 uint64_t ret_ref = tag_ptr(ret_copy, true);
30172 uint64_t __attribute__((export_name("TS_DecodeError_unknown_required_feature"))) TS_DecodeError_unknown_required_feature() {
30173 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30174 *ret_copy = DecodeError_unknown_required_feature();
30175 uint64_t ret_ref = tag_ptr(ret_copy, true);
30179 uint64_t __attribute__((export_name("TS_DecodeError_invalid_value"))) TS_DecodeError_invalid_value() {
30180 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30181 *ret_copy = DecodeError_invalid_value();
30182 uint64_t ret_ref = tag_ptr(ret_copy, true);
30186 uint64_t __attribute__((export_name("TS_DecodeError_short_read"))) TS_DecodeError_short_read() {
30187 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30188 *ret_copy = DecodeError_short_read();
30189 uint64_t ret_ref = tag_ptr(ret_copy, true);
30193 uint64_t __attribute__((export_name("TS_DecodeError_bad_length_descriptor"))) TS_DecodeError_bad_length_descriptor() {
30194 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30195 *ret_copy = DecodeError_bad_length_descriptor();
30196 uint64_t ret_ref = tag_ptr(ret_copy, true);
30200 uint64_t __attribute__((export_name("TS_DecodeError_io"))) TS_DecodeError_io(uint32_t a) {
30201 LDKIOError a_conv = LDKIOError_from_js(a);
30202 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30203 *ret_copy = DecodeError_io(a_conv);
30204 uint64_t ret_ref = tag_ptr(ret_copy, true);
30208 uint64_t __attribute__((export_name("TS_DecodeError_unsupported_compression"))) TS_DecodeError_unsupported_compression() {
30209 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
30210 *ret_copy = DecodeError_unsupported_compression();
30211 uint64_t ret_ref = tag_ptr(ret_copy, true);
30215 jboolean __attribute__((export_name("TS_DecodeError_eq"))) TS_DecodeError_eq(uint64_t a, uint64_t b) {
30216 LDKDecodeError* a_conv = (LDKDecodeError*)untag_ptr(a);
30217 LDKDecodeError* b_conv = (LDKDecodeError*)untag_ptr(b);
30218 jboolean ret_conv = DecodeError_eq(a_conv, b_conv);
30222 void __attribute__((export_name("TS_Init_free"))) TS_Init_free(uint64_t this_obj) {
30223 LDKInit this_obj_conv;
30224 this_obj_conv.inner = untag_ptr(this_obj);
30225 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30226 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30227 Init_free(this_obj_conv);
30230 uint64_t __attribute__((export_name("TS_Init_get_features"))) TS_Init_get_features(uint64_t this_ptr) {
30231 LDKInit this_ptr_conv;
30232 this_ptr_conv.inner = untag_ptr(this_ptr);
30233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30235 this_ptr_conv.is_owned = false;
30236 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
30237 uint64_t ret_ref = 0;
30238 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30239 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30243 void __attribute__((export_name("TS_Init_set_features"))) TS_Init_set_features(uint64_t this_ptr, uint64_t val) {
30244 LDKInit this_ptr_conv;
30245 this_ptr_conv.inner = untag_ptr(this_ptr);
30246 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30248 this_ptr_conv.is_owned = false;
30249 LDKInitFeatures val_conv;
30250 val_conv.inner = untag_ptr(val);
30251 val_conv.is_owned = ptr_is_owned(val);
30252 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
30253 val_conv = InitFeatures_clone(&val_conv);
30254 Init_set_features(&this_ptr_conv, val_conv);
30257 uint64_t __attribute__((export_name("TS_Init_get_remote_network_address"))) TS_Init_get_remote_network_address(uint64_t this_ptr) {
30258 LDKInit this_ptr_conv;
30259 this_ptr_conv.inner = untag_ptr(this_ptr);
30260 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30262 this_ptr_conv.is_owned = false;
30263 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
30264 *ret_copy = Init_get_remote_network_address(&this_ptr_conv);
30265 uint64_t ret_ref = tag_ptr(ret_copy, true);
30269 void __attribute__((export_name("TS_Init_set_remote_network_address"))) TS_Init_set_remote_network_address(uint64_t this_ptr, uint64_t val) {
30270 LDKInit this_ptr_conv;
30271 this_ptr_conv.inner = untag_ptr(this_ptr);
30272 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30274 this_ptr_conv.is_owned = false;
30275 void* val_ptr = untag_ptr(val);
30276 CHECK_ACCESS(val_ptr);
30277 LDKCOption_NetAddressZ val_conv = *(LDKCOption_NetAddressZ*)(val_ptr);
30278 val_conv = COption_NetAddressZ_clone((LDKCOption_NetAddressZ*)untag_ptr(val));
30279 Init_set_remote_network_address(&this_ptr_conv, val_conv);
30282 uint64_t __attribute__((export_name("TS_Init_new"))) TS_Init_new(uint64_t features_arg, uint64_t remote_network_address_arg) {
30283 LDKInitFeatures features_arg_conv;
30284 features_arg_conv.inner = untag_ptr(features_arg);
30285 features_arg_conv.is_owned = ptr_is_owned(features_arg);
30286 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
30287 features_arg_conv = InitFeatures_clone(&features_arg_conv);
30288 void* remote_network_address_arg_ptr = untag_ptr(remote_network_address_arg);
30289 CHECK_ACCESS(remote_network_address_arg_ptr);
30290 LDKCOption_NetAddressZ remote_network_address_arg_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_arg_ptr);
30291 LDKInit ret_var = Init_new(features_arg_conv, remote_network_address_arg_conv);
30292 uint64_t ret_ref = 0;
30293 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30294 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30298 static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
30299 LDKInit ret_var = Init_clone(arg);
30300 uint64_t ret_ref = 0;
30301 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30302 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30305 int64_t __attribute__((export_name("TS_Init_clone_ptr"))) TS_Init_clone_ptr(uint64_t arg) {
30307 arg_conv.inner = untag_ptr(arg);
30308 arg_conv.is_owned = ptr_is_owned(arg);
30309 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30310 arg_conv.is_owned = false;
30311 int64_t ret_conv = Init_clone_ptr(&arg_conv);
30315 uint64_t __attribute__((export_name("TS_Init_clone"))) TS_Init_clone(uint64_t orig) {
30317 orig_conv.inner = untag_ptr(orig);
30318 orig_conv.is_owned = ptr_is_owned(orig);
30319 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30320 orig_conv.is_owned = false;
30321 LDKInit ret_var = Init_clone(&orig_conv);
30322 uint64_t ret_ref = 0;
30323 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30324 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30328 jboolean __attribute__((export_name("TS_Init_eq"))) TS_Init_eq(uint64_t a, uint64_t b) {
30330 a_conv.inner = untag_ptr(a);
30331 a_conv.is_owned = ptr_is_owned(a);
30332 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30333 a_conv.is_owned = false;
30335 b_conv.inner = untag_ptr(b);
30336 b_conv.is_owned = ptr_is_owned(b);
30337 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30338 b_conv.is_owned = false;
30339 jboolean ret_conv = Init_eq(&a_conv, &b_conv);
30343 void __attribute__((export_name("TS_ErrorMessage_free"))) TS_ErrorMessage_free(uint64_t this_obj) {
30344 LDKErrorMessage this_obj_conv;
30345 this_obj_conv.inner = untag_ptr(this_obj);
30346 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30348 ErrorMessage_free(this_obj_conv);
30351 int8_tArray __attribute__((export_name("TS_ErrorMessage_get_channel_id"))) TS_ErrorMessage_get_channel_id(uint64_t this_ptr) {
30352 LDKErrorMessage this_ptr_conv;
30353 this_ptr_conv.inner = untag_ptr(this_ptr);
30354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30356 this_ptr_conv.is_owned = false;
30357 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30358 memcpy(ret_arr->elems, *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
30362 void __attribute__((export_name("TS_ErrorMessage_set_channel_id"))) TS_ErrorMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
30363 LDKErrorMessage this_ptr_conv;
30364 this_ptr_conv.inner = untag_ptr(this_ptr);
30365 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30367 this_ptr_conv.is_owned = false;
30368 LDKThirtyTwoBytes val_ref;
30369 CHECK(val->arr_len == 32);
30370 memcpy(val_ref.data, val->elems, 32); FREE(val);
30371 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
30374 jstring __attribute__((export_name("TS_ErrorMessage_get_data"))) TS_ErrorMessage_get_data(uint64_t this_ptr) {
30375 LDKErrorMessage this_ptr_conv;
30376 this_ptr_conv.inner = untag_ptr(this_ptr);
30377 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30379 this_ptr_conv.is_owned = false;
30380 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
30381 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
30386 void __attribute__((export_name("TS_ErrorMessage_set_data"))) TS_ErrorMessage_set_data(uint64_t this_ptr, jstring val) {
30387 LDKErrorMessage this_ptr_conv;
30388 this_ptr_conv.inner = untag_ptr(this_ptr);
30389 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30390 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30391 this_ptr_conv.is_owned = false;
30392 LDKStr val_conv = str_ref_to_owned_c(val);
30393 ErrorMessage_set_data(&this_ptr_conv, val_conv);
30396 uint64_t __attribute__((export_name("TS_ErrorMessage_new"))) TS_ErrorMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
30397 LDKThirtyTwoBytes channel_id_arg_ref;
30398 CHECK(channel_id_arg->arr_len == 32);
30399 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30400 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
30401 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
30402 uint64_t ret_ref = 0;
30403 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30404 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30408 static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
30409 LDKErrorMessage ret_var = ErrorMessage_clone(arg);
30410 uint64_t ret_ref = 0;
30411 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30412 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30415 int64_t __attribute__((export_name("TS_ErrorMessage_clone_ptr"))) TS_ErrorMessage_clone_ptr(uint64_t arg) {
30416 LDKErrorMessage arg_conv;
30417 arg_conv.inner = untag_ptr(arg);
30418 arg_conv.is_owned = ptr_is_owned(arg);
30419 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30420 arg_conv.is_owned = false;
30421 int64_t ret_conv = ErrorMessage_clone_ptr(&arg_conv);
30425 uint64_t __attribute__((export_name("TS_ErrorMessage_clone"))) TS_ErrorMessage_clone(uint64_t orig) {
30426 LDKErrorMessage orig_conv;
30427 orig_conv.inner = untag_ptr(orig);
30428 orig_conv.is_owned = ptr_is_owned(orig);
30429 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30430 orig_conv.is_owned = false;
30431 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
30432 uint64_t ret_ref = 0;
30433 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30434 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30438 jboolean __attribute__((export_name("TS_ErrorMessage_eq"))) TS_ErrorMessage_eq(uint64_t a, uint64_t b) {
30439 LDKErrorMessage a_conv;
30440 a_conv.inner = untag_ptr(a);
30441 a_conv.is_owned = ptr_is_owned(a);
30442 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30443 a_conv.is_owned = false;
30444 LDKErrorMessage b_conv;
30445 b_conv.inner = untag_ptr(b);
30446 b_conv.is_owned = ptr_is_owned(b);
30447 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30448 b_conv.is_owned = false;
30449 jboolean ret_conv = ErrorMessage_eq(&a_conv, &b_conv);
30453 void __attribute__((export_name("TS_WarningMessage_free"))) TS_WarningMessage_free(uint64_t this_obj) {
30454 LDKWarningMessage this_obj_conv;
30455 this_obj_conv.inner = untag_ptr(this_obj);
30456 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30458 WarningMessage_free(this_obj_conv);
30461 int8_tArray __attribute__((export_name("TS_WarningMessage_get_channel_id"))) TS_WarningMessage_get_channel_id(uint64_t this_ptr) {
30462 LDKWarningMessage this_ptr_conv;
30463 this_ptr_conv.inner = untag_ptr(this_ptr);
30464 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30466 this_ptr_conv.is_owned = false;
30467 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30468 memcpy(ret_arr->elems, *WarningMessage_get_channel_id(&this_ptr_conv), 32);
30472 void __attribute__((export_name("TS_WarningMessage_set_channel_id"))) TS_WarningMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
30473 LDKWarningMessage this_ptr_conv;
30474 this_ptr_conv.inner = untag_ptr(this_ptr);
30475 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30477 this_ptr_conv.is_owned = false;
30478 LDKThirtyTwoBytes val_ref;
30479 CHECK(val->arr_len == 32);
30480 memcpy(val_ref.data, val->elems, 32); FREE(val);
30481 WarningMessage_set_channel_id(&this_ptr_conv, val_ref);
30484 jstring __attribute__((export_name("TS_WarningMessage_get_data"))) TS_WarningMessage_get_data(uint64_t this_ptr) {
30485 LDKWarningMessage this_ptr_conv;
30486 this_ptr_conv.inner = untag_ptr(this_ptr);
30487 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30488 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30489 this_ptr_conv.is_owned = false;
30490 LDKStr ret_str = WarningMessage_get_data(&this_ptr_conv);
30491 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
30496 void __attribute__((export_name("TS_WarningMessage_set_data"))) TS_WarningMessage_set_data(uint64_t this_ptr, jstring val) {
30497 LDKWarningMessage this_ptr_conv;
30498 this_ptr_conv.inner = untag_ptr(this_ptr);
30499 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30501 this_ptr_conv.is_owned = false;
30502 LDKStr val_conv = str_ref_to_owned_c(val);
30503 WarningMessage_set_data(&this_ptr_conv, val_conv);
30506 uint64_t __attribute__((export_name("TS_WarningMessage_new"))) TS_WarningMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
30507 LDKThirtyTwoBytes channel_id_arg_ref;
30508 CHECK(channel_id_arg->arr_len == 32);
30509 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30510 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
30511 LDKWarningMessage ret_var = WarningMessage_new(channel_id_arg_ref, data_arg_conv);
30512 uint64_t ret_ref = 0;
30513 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30514 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30518 static inline uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg) {
30519 LDKWarningMessage ret_var = WarningMessage_clone(arg);
30520 uint64_t ret_ref = 0;
30521 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30522 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30525 int64_t __attribute__((export_name("TS_WarningMessage_clone_ptr"))) TS_WarningMessage_clone_ptr(uint64_t arg) {
30526 LDKWarningMessage arg_conv;
30527 arg_conv.inner = untag_ptr(arg);
30528 arg_conv.is_owned = ptr_is_owned(arg);
30529 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30530 arg_conv.is_owned = false;
30531 int64_t ret_conv = WarningMessage_clone_ptr(&arg_conv);
30535 uint64_t __attribute__((export_name("TS_WarningMessage_clone"))) TS_WarningMessage_clone(uint64_t orig) {
30536 LDKWarningMessage orig_conv;
30537 orig_conv.inner = untag_ptr(orig);
30538 orig_conv.is_owned = ptr_is_owned(orig);
30539 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30540 orig_conv.is_owned = false;
30541 LDKWarningMessage ret_var = WarningMessage_clone(&orig_conv);
30542 uint64_t ret_ref = 0;
30543 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30544 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30548 jboolean __attribute__((export_name("TS_WarningMessage_eq"))) TS_WarningMessage_eq(uint64_t a, uint64_t b) {
30549 LDKWarningMessage a_conv;
30550 a_conv.inner = untag_ptr(a);
30551 a_conv.is_owned = ptr_is_owned(a);
30552 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30553 a_conv.is_owned = false;
30554 LDKWarningMessage b_conv;
30555 b_conv.inner = untag_ptr(b);
30556 b_conv.is_owned = ptr_is_owned(b);
30557 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30558 b_conv.is_owned = false;
30559 jboolean ret_conv = WarningMessage_eq(&a_conv, &b_conv);
30563 void __attribute__((export_name("TS_Ping_free"))) TS_Ping_free(uint64_t this_obj) {
30564 LDKPing this_obj_conv;
30565 this_obj_conv.inner = untag_ptr(this_obj);
30566 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30568 Ping_free(this_obj_conv);
30571 int16_t __attribute__((export_name("TS_Ping_get_ponglen"))) TS_Ping_get_ponglen(uint64_t this_ptr) {
30572 LDKPing this_ptr_conv;
30573 this_ptr_conv.inner = untag_ptr(this_ptr);
30574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30576 this_ptr_conv.is_owned = false;
30577 int16_t ret_conv = Ping_get_ponglen(&this_ptr_conv);
30581 void __attribute__((export_name("TS_Ping_set_ponglen"))) TS_Ping_set_ponglen(uint64_t this_ptr, int16_t val) {
30582 LDKPing this_ptr_conv;
30583 this_ptr_conv.inner = untag_ptr(this_ptr);
30584 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30586 this_ptr_conv.is_owned = false;
30587 Ping_set_ponglen(&this_ptr_conv, val);
30590 int16_t __attribute__((export_name("TS_Ping_get_byteslen"))) TS_Ping_get_byteslen(uint64_t this_ptr) {
30591 LDKPing this_ptr_conv;
30592 this_ptr_conv.inner = untag_ptr(this_ptr);
30593 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30595 this_ptr_conv.is_owned = false;
30596 int16_t ret_conv = Ping_get_byteslen(&this_ptr_conv);
30600 void __attribute__((export_name("TS_Ping_set_byteslen"))) TS_Ping_set_byteslen(uint64_t this_ptr, int16_t val) {
30601 LDKPing this_ptr_conv;
30602 this_ptr_conv.inner = untag_ptr(this_ptr);
30603 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30604 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30605 this_ptr_conv.is_owned = false;
30606 Ping_set_byteslen(&this_ptr_conv, val);
30609 uint64_t __attribute__((export_name("TS_Ping_new"))) TS_Ping_new(int16_t ponglen_arg, int16_t byteslen_arg) {
30610 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
30611 uint64_t ret_ref = 0;
30612 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30613 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30617 static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
30618 LDKPing ret_var = Ping_clone(arg);
30619 uint64_t ret_ref = 0;
30620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30624 int64_t __attribute__((export_name("TS_Ping_clone_ptr"))) TS_Ping_clone_ptr(uint64_t arg) {
30626 arg_conv.inner = untag_ptr(arg);
30627 arg_conv.is_owned = ptr_is_owned(arg);
30628 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30629 arg_conv.is_owned = false;
30630 int64_t ret_conv = Ping_clone_ptr(&arg_conv);
30634 uint64_t __attribute__((export_name("TS_Ping_clone"))) TS_Ping_clone(uint64_t orig) {
30636 orig_conv.inner = untag_ptr(orig);
30637 orig_conv.is_owned = ptr_is_owned(orig);
30638 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30639 orig_conv.is_owned = false;
30640 LDKPing ret_var = Ping_clone(&orig_conv);
30641 uint64_t ret_ref = 0;
30642 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30643 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30647 jboolean __attribute__((export_name("TS_Ping_eq"))) TS_Ping_eq(uint64_t a, uint64_t b) {
30649 a_conv.inner = untag_ptr(a);
30650 a_conv.is_owned = ptr_is_owned(a);
30651 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30652 a_conv.is_owned = false;
30654 b_conv.inner = untag_ptr(b);
30655 b_conv.is_owned = ptr_is_owned(b);
30656 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30657 b_conv.is_owned = false;
30658 jboolean ret_conv = Ping_eq(&a_conv, &b_conv);
30662 void __attribute__((export_name("TS_Pong_free"))) TS_Pong_free(uint64_t this_obj) {
30663 LDKPong this_obj_conv;
30664 this_obj_conv.inner = untag_ptr(this_obj);
30665 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30667 Pong_free(this_obj_conv);
30670 int16_t __attribute__((export_name("TS_Pong_get_byteslen"))) TS_Pong_get_byteslen(uint64_t this_ptr) {
30671 LDKPong this_ptr_conv;
30672 this_ptr_conv.inner = untag_ptr(this_ptr);
30673 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30675 this_ptr_conv.is_owned = false;
30676 int16_t ret_conv = Pong_get_byteslen(&this_ptr_conv);
30680 void __attribute__((export_name("TS_Pong_set_byteslen"))) TS_Pong_set_byteslen(uint64_t this_ptr, int16_t val) {
30681 LDKPong this_ptr_conv;
30682 this_ptr_conv.inner = untag_ptr(this_ptr);
30683 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30685 this_ptr_conv.is_owned = false;
30686 Pong_set_byteslen(&this_ptr_conv, val);
30689 uint64_t __attribute__((export_name("TS_Pong_new"))) TS_Pong_new(int16_t byteslen_arg) {
30690 LDKPong ret_var = Pong_new(byteslen_arg);
30691 uint64_t ret_ref = 0;
30692 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30693 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30697 static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
30698 LDKPong ret_var = Pong_clone(arg);
30699 uint64_t ret_ref = 0;
30700 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30701 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30704 int64_t __attribute__((export_name("TS_Pong_clone_ptr"))) TS_Pong_clone_ptr(uint64_t arg) {
30706 arg_conv.inner = untag_ptr(arg);
30707 arg_conv.is_owned = ptr_is_owned(arg);
30708 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30709 arg_conv.is_owned = false;
30710 int64_t ret_conv = Pong_clone_ptr(&arg_conv);
30714 uint64_t __attribute__((export_name("TS_Pong_clone"))) TS_Pong_clone(uint64_t orig) {
30716 orig_conv.inner = untag_ptr(orig);
30717 orig_conv.is_owned = ptr_is_owned(orig);
30718 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30719 orig_conv.is_owned = false;
30720 LDKPong ret_var = Pong_clone(&orig_conv);
30721 uint64_t ret_ref = 0;
30722 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30723 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30727 jboolean __attribute__((export_name("TS_Pong_eq"))) TS_Pong_eq(uint64_t a, uint64_t b) {
30729 a_conv.inner = untag_ptr(a);
30730 a_conv.is_owned = ptr_is_owned(a);
30731 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30732 a_conv.is_owned = false;
30734 b_conv.inner = untag_ptr(b);
30735 b_conv.is_owned = ptr_is_owned(b);
30736 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30737 b_conv.is_owned = false;
30738 jboolean ret_conv = Pong_eq(&a_conv, &b_conv);
30742 void __attribute__((export_name("TS_OpenChannel_free"))) TS_OpenChannel_free(uint64_t this_obj) {
30743 LDKOpenChannel this_obj_conv;
30744 this_obj_conv.inner = untag_ptr(this_obj);
30745 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30747 OpenChannel_free(this_obj_conv);
30750 int8_tArray __attribute__((export_name("TS_OpenChannel_get_chain_hash"))) TS_OpenChannel_get_chain_hash(uint64_t this_ptr) {
30751 LDKOpenChannel this_ptr_conv;
30752 this_ptr_conv.inner = untag_ptr(this_ptr);
30753 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30755 this_ptr_conv.is_owned = false;
30756 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30757 memcpy(ret_arr->elems, *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
30761 void __attribute__((export_name("TS_OpenChannel_set_chain_hash"))) TS_OpenChannel_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
30762 LDKOpenChannel this_ptr_conv;
30763 this_ptr_conv.inner = untag_ptr(this_ptr);
30764 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30766 this_ptr_conv.is_owned = false;
30767 LDKThirtyTwoBytes val_ref;
30768 CHECK(val->arr_len == 32);
30769 memcpy(val_ref.data, val->elems, 32); FREE(val);
30770 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
30773 int8_tArray __attribute__((export_name("TS_OpenChannel_get_temporary_channel_id"))) TS_OpenChannel_get_temporary_channel_id(uint64_t this_ptr) {
30774 LDKOpenChannel this_ptr_conv;
30775 this_ptr_conv.inner = untag_ptr(this_ptr);
30776 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30777 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30778 this_ptr_conv.is_owned = false;
30779 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30780 memcpy(ret_arr->elems, *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
30784 void __attribute__((export_name("TS_OpenChannel_set_temporary_channel_id"))) TS_OpenChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
30785 LDKOpenChannel this_ptr_conv;
30786 this_ptr_conv.inner = untag_ptr(this_ptr);
30787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30789 this_ptr_conv.is_owned = false;
30790 LDKThirtyTwoBytes val_ref;
30791 CHECK(val->arr_len == 32);
30792 memcpy(val_ref.data, val->elems, 32); FREE(val);
30793 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
30796 int64_t __attribute__((export_name("TS_OpenChannel_get_funding_satoshis"))) TS_OpenChannel_get_funding_satoshis(uint64_t this_ptr) {
30797 LDKOpenChannel this_ptr_conv;
30798 this_ptr_conv.inner = untag_ptr(this_ptr);
30799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30801 this_ptr_conv.is_owned = false;
30802 int64_t ret_conv = OpenChannel_get_funding_satoshis(&this_ptr_conv);
30806 void __attribute__((export_name("TS_OpenChannel_set_funding_satoshis"))) TS_OpenChannel_set_funding_satoshis(uint64_t this_ptr, int64_t val) {
30807 LDKOpenChannel this_ptr_conv;
30808 this_ptr_conv.inner = untag_ptr(this_ptr);
30809 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30811 this_ptr_conv.is_owned = false;
30812 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
30815 int64_t __attribute__((export_name("TS_OpenChannel_get_push_msat"))) TS_OpenChannel_get_push_msat(uint64_t this_ptr) {
30816 LDKOpenChannel this_ptr_conv;
30817 this_ptr_conv.inner = untag_ptr(this_ptr);
30818 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30820 this_ptr_conv.is_owned = false;
30821 int64_t ret_conv = OpenChannel_get_push_msat(&this_ptr_conv);
30825 void __attribute__((export_name("TS_OpenChannel_set_push_msat"))) TS_OpenChannel_set_push_msat(uint64_t this_ptr, int64_t val) {
30826 LDKOpenChannel this_ptr_conv;
30827 this_ptr_conv.inner = untag_ptr(this_ptr);
30828 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30829 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30830 this_ptr_conv.is_owned = false;
30831 OpenChannel_set_push_msat(&this_ptr_conv, val);
30834 int64_t __attribute__((export_name("TS_OpenChannel_get_dust_limit_satoshis"))) TS_OpenChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
30835 LDKOpenChannel this_ptr_conv;
30836 this_ptr_conv.inner = untag_ptr(this_ptr);
30837 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30839 this_ptr_conv.is_owned = false;
30840 int64_t ret_conv = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
30844 void __attribute__((export_name("TS_OpenChannel_set_dust_limit_satoshis"))) TS_OpenChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
30845 LDKOpenChannel this_ptr_conv;
30846 this_ptr_conv.inner = untag_ptr(this_ptr);
30847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30849 this_ptr_conv.is_owned = false;
30850 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
30853 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) {
30854 LDKOpenChannel this_ptr_conv;
30855 this_ptr_conv.inner = untag_ptr(this_ptr);
30856 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30858 this_ptr_conv.is_owned = false;
30859 int64_t ret_conv = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
30863 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) {
30864 LDKOpenChannel this_ptr_conv;
30865 this_ptr_conv.inner = untag_ptr(this_ptr);
30866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30868 this_ptr_conv.is_owned = false;
30869 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
30872 int64_t __attribute__((export_name("TS_OpenChannel_get_channel_reserve_satoshis"))) TS_OpenChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
30873 LDKOpenChannel this_ptr_conv;
30874 this_ptr_conv.inner = untag_ptr(this_ptr);
30875 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30877 this_ptr_conv.is_owned = false;
30878 int64_t ret_conv = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
30882 void __attribute__((export_name("TS_OpenChannel_set_channel_reserve_satoshis"))) TS_OpenChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
30883 LDKOpenChannel this_ptr_conv;
30884 this_ptr_conv.inner = untag_ptr(this_ptr);
30885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30887 this_ptr_conv.is_owned = false;
30888 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
30891 int64_t __attribute__((export_name("TS_OpenChannel_get_htlc_minimum_msat"))) TS_OpenChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
30892 LDKOpenChannel this_ptr_conv;
30893 this_ptr_conv.inner = untag_ptr(this_ptr);
30894 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30896 this_ptr_conv.is_owned = false;
30897 int64_t ret_conv = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
30901 void __attribute__((export_name("TS_OpenChannel_set_htlc_minimum_msat"))) TS_OpenChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
30902 LDKOpenChannel this_ptr_conv;
30903 this_ptr_conv.inner = untag_ptr(this_ptr);
30904 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30906 this_ptr_conv.is_owned = false;
30907 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
30910 int32_t __attribute__((export_name("TS_OpenChannel_get_feerate_per_kw"))) TS_OpenChannel_get_feerate_per_kw(uint64_t this_ptr) {
30911 LDKOpenChannel this_ptr_conv;
30912 this_ptr_conv.inner = untag_ptr(this_ptr);
30913 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30914 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30915 this_ptr_conv.is_owned = false;
30916 int32_t ret_conv = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
30920 void __attribute__((export_name("TS_OpenChannel_set_feerate_per_kw"))) TS_OpenChannel_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
30921 LDKOpenChannel this_ptr_conv;
30922 this_ptr_conv.inner = untag_ptr(this_ptr);
30923 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30925 this_ptr_conv.is_owned = false;
30926 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
30929 int16_t __attribute__((export_name("TS_OpenChannel_get_to_self_delay"))) TS_OpenChannel_get_to_self_delay(uint64_t this_ptr) {
30930 LDKOpenChannel this_ptr_conv;
30931 this_ptr_conv.inner = untag_ptr(this_ptr);
30932 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30933 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30934 this_ptr_conv.is_owned = false;
30935 int16_t ret_conv = OpenChannel_get_to_self_delay(&this_ptr_conv);
30939 void __attribute__((export_name("TS_OpenChannel_set_to_self_delay"))) TS_OpenChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
30940 LDKOpenChannel this_ptr_conv;
30941 this_ptr_conv.inner = untag_ptr(this_ptr);
30942 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30943 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30944 this_ptr_conv.is_owned = false;
30945 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
30948 int16_t __attribute__((export_name("TS_OpenChannel_get_max_accepted_htlcs"))) TS_OpenChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
30949 LDKOpenChannel this_ptr_conv;
30950 this_ptr_conv.inner = untag_ptr(this_ptr);
30951 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30953 this_ptr_conv.is_owned = false;
30954 int16_t ret_conv = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
30958 void __attribute__((export_name("TS_OpenChannel_set_max_accepted_htlcs"))) TS_OpenChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
30959 LDKOpenChannel this_ptr_conv;
30960 this_ptr_conv.inner = untag_ptr(this_ptr);
30961 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30963 this_ptr_conv.is_owned = false;
30964 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
30967 int8_tArray __attribute__((export_name("TS_OpenChannel_get_funding_pubkey"))) TS_OpenChannel_get_funding_pubkey(uint64_t this_ptr) {
30968 LDKOpenChannel this_ptr_conv;
30969 this_ptr_conv.inner = untag_ptr(this_ptr);
30970 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30972 this_ptr_conv.is_owned = false;
30973 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30974 memcpy(ret_arr->elems, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
30978 void __attribute__((export_name("TS_OpenChannel_set_funding_pubkey"))) TS_OpenChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
30979 LDKOpenChannel this_ptr_conv;
30980 this_ptr_conv.inner = untag_ptr(this_ptr);
30981 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30983 this_ptr_conv.is_owned = false;
30984 LDKPublicKey val_ref;
30985 CHECK(val->arr_len == 33);
30986 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30987 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
30990 int8_tArray __attribute__((export_name("TS_OpenChannel_get_revocation_basepoint"))) TS_OpenChannel_get_revocation_basepoint(uint64_t this_ptr) {
30991 LDKOpenChannel this_ptr_conv;
30992 this_ptr_conv.inner = untag_ptr(this_ptr);
30993 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30995 this_ptr_conv.is_owned = false;
30996 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30997 memcpy(ret_arr->elems, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
31001 void __attribute__((export_name("TS_OpenChannel_set_revocation_basepoint"))) TS_OpenChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
31002 LDKOpenChannel this_ptr_conv;
31003 this_ptr_conv.inner = untag_ptr(this_ptr);
31004 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31006 this_ptr_conv.is_owned = false;
31007 LDKPublicKey val_ref;
31008 CHECK(val->arr_len == 33);
31009 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31010 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
31013 int8_tArray __attribute__((export_name("TS_OpenChannel_get_payment_point"))) TS_OpenChannel_get_payment_point(uint64_t this_ptr) {
31014 LDKOpenChannel this_ptr_conv;
31015 this_ptr_conv.inner = untag_ptr(this_ptr);
31016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31018 this_ptr_conv.is_owned = false;
31019 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31020 memcpy(ret_arr->elems, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
31024 void __attribute__((export_name("TS_OpenChannel_set_payment_point"))) TS_OpenChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
31025 LDKOpenChannel this_ptr_conv;
31026 this_ptr_conv.inner = untag_ptr(this_ptr);
31027 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31028 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31029 this_ptr_conv.is_owned = false;
31030 LDKPublicKey val_ref;
31031 CHECK(val->arr_len == 33);
31032 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31033 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
31036 int8_tArray __attribute__((export_name("TS_OpenChannel_get_delayed_payment_basepoint"))) TS_OpenChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
31037 LDKOpenChannel this_ptr_conv;
31038 this_ptr_conv.inner = untag_ptr(this_ptr);
31039 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31040 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31041 this_ptr_conv.is_owned = false;
31042 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31043 memcpy(ret_arr->elems, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
31047 void __attribute__((export_name("TS_OpenChannel_set_delayed_payment_basepoint"))) TS_OpenChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
31048 LDKOpenChannel this_ptr_conv;
31049 this_ptr_conv.inner = untag_ptr(this_ptr);
31050 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31052 this_ptr_conv.is_owned = false;
31053 LDKPublicKey val_ref;
31054 CHECK(val->arr_len == 33);
31055 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31056 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
31059 int8_tArray __attribute__((export_name("TS_OpenChannel_get_htlc_basepoint"))) TS_OpenChannel_get_htlc_basepoint(uint64_t this_ptr) {
31060 LDKOpenChannel this_ptr_conv;
31061 this_ptr_conv.inner = untag_ptr(this_ptr);
31062 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31063 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31064 this_ptr_conv.is_owned = false;
31065 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31066 memcpy(ret_arr->elems, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
31070 void __attribute__((export_name("TS_OpenChannel_set_htlc_basepoint"))) TS_OpenChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
31071 LDKOpenChannel this_ptr_conv;
31072 this_ptr_conv.inner = untag_ptr(this_ptr);
31073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31075 this_ptr_conv.is_owned = false;
31076 LDKPublicKey val_ref;
31077 CHECK(val->arr_len == 33);
31078 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31079 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
31082 int8_tArray __attribute__((export_name("TS_OpenChannel_get_first_per_commitment_point"))) TS_OpenChannel_get_first_per_commitment_point(uint64_t this_ptr) {
31083 LDKOpenChannel this_ptr_conv;
31084 this_ptr_conv.inner = untag_ptr(this_ptr);
31085 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31087 this_ptr_conv.is_owned = false;
31088 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31089 memcpy(ret_arr->elems, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31093 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) {
31094 LDKOpenChannel this_ptr_conv;
31095 this_ptr_conv.inner = untag_ptr(this_ptr);
31096 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31098 this_ptr_conv.is_owned = false;
31099 LDKPublicKey val_ref;
31100 CHECK(val->arr_len == 33);
31101 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31102 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
31105 int8_t __attribute__((export_name("TS_OpenChannel_get_channel_flags"))) TS_OpenChannel_get_channel_flags(uint64_t this_ptr) {
31106 LDKOpenChannel this_ptr_conv;
31107 this_ptr_conv.inner = untag_ptr(this_ptr);
31108 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31110 this_ptr_conv.is_owned = false;
31111 int8_t ret_conv = OpenChannel_get_channel_flags(&this_ptr_conv);
31115 void __attribute__((export_name("TS_OpenChannel_set_channel_flags"))) TS_OpenChannel_set_channel_flags(uint64_t this_ptr, int8_t val) {
31116 LDKOpenChannel this_ptr_conv;
31117 this_ptr_conv.inner = untag_ptr(this_ptr);
31118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31120 this_ptr_conv.is_owned = false;
31121 OpenChannel_set_channel_flags(&this_ptr_conv, val);
31124 uint64_t __attribute__((export_name("TS_OpenChannel_get_channel_type"))) TS_OpenChannel_get_channel_type(uint64_t this_ptr) {
31125 LDKOpenChannel this_ptr_conv;
31126 this_ptr_conv.inner = untag_ptr(this_ptr);
31127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31129 this_ptr_conv.is_owned = false;
31130 LDKChannelTypeFeatures ret_var = OpenChannel_get_channel_type(&this_ptr_conv);
31131 uint64_t ret_ref = 0;
31132 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31133 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31137 void __attribute__((export_name("TS_OpenChannel_set_channel_type"))) TS_OpenChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
31138 LDKOpenChannel this_ptr_conv;
31139 this_ptr_conv.inner = untag_ptr(this_ptr);
31140 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31142 this_ptr_conv.is_owned = false;
31143 LDKChannelTypeFeatures val_conv;
31144 val_conv.inner = untag_ptr(val);
31145 val_conv.is_owned = ptr_is_owned(val);
31146 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31147 val_conv = ChannelTypeFeatures_clone(&val_conv);
31148 OpenChannel_set_channel_type(&this_ptr_conv, val_conv);
31151 static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
31152 LDKOpenChannel ret_var = OpenChannel_clone(arg);
31153 uint64_t ret_ref = 0;
31154 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31155 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31158 int64_t __attribute__((export_name("TS_OpenChannel_clone_ptr"))) TS_OpenChannel_clone_ptr(uint64_t arg) {
31159 LDKOpenChannel arg_conv;
31160 arg_conv.inner = untag_ptr(arg);
31161 arg_conv.is_owned = ptr_is_owned(arg);
31162 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31163 arg_conv.is_owned = false;
31164 int64_t ret_conv = OpenChannel_clone_ptr(&arg_conv);
31168 uint64_t __attribute__((export_name("TS_OpenChannel_clone"))) TS_OpenChannel_clone(uint64_t orig) {
31169 LDKOpenChannel orig_conv;
31170 orig_conv.inner = untag_ptr(orig);
31171 orig_conv.is_owned = ptr_is_owned(orig);
31172 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31173 orig_conv.is_owned = false;
31174 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
31175 uint64_t ret_ref = 0;
31176 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31177 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31181 jboolean __attribute__((export_name("TS_OpenChannel_eq"))) TS_OpenChannel_eq(uint64_t a, uint64_t b) {
31182 LDKOpenChannel a_conv;
31183 a_conv.inner = untag_ptr(a);
31184 a_conv.is_owned = ptr_is_owned(a);
31185 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31186 a_conv.is_owned = false;
31187 LDKOpenChannel b_conv;
31188 b_conv.inner = untag_ptr(b);
31189 b_conv.is_owned = ptr_is_owned(b);
31190 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31191 b_conv.is_owned = false;
31192 jboolean ret_conv = OpenChannel_eq(&a_conv, &b_conv);
31196 void __attribute__((export_name("TS_AcceptChannel_free"))) TS_AcceptChannel_free(uint64_t this_obj) {
31197 LDKAcceptChannel this_obj_conv;
31198 this_obj_conv.inner = untag_ptr(this_obj);
31199 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31200 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31201 AcceptChannel_free(this_obj_conv);
31204 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_temporary_channel_id"))) TS_AcceptChannel_get_temporary_channel_id(uint64_t this_ptr) {
31205 LDKAcceptChannel this_ptr_conv;
31206 this_ptr_conv.inner = untag_ptr(this_ptr);
31207 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31209 this_ptr_conv.is_owned = false;
31210 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31211 memcpy(ret_arr->elems, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
31215 void __attribute__((export_name("TS_AcceptChannel_set_temporary_channel_id"))) TS_AcceptChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
31216 LDKAcceptChannel this_ptr_conv;
31217 this_ptr_conv.inner = untag_ptr(this_ptr);
31218 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31220 this_ptr_conv.is_owned = false;
31221 LDKThirtyTwoBytes val_ref;
31222 CHECK(val->arr_len == 32);
31223 memcpy(val_ref.data, val->elems, 32); FREE(val);
31224 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
31227 int64_t __attribute__((export_name("TS_AcceptChannel_get_dust_limit_satoshis"))) TS_AcceptChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
31228 LDKAcceptChannel this_ptr_conv;
31229 this_ptr_conv.inner = untag_ptr(this_ptr);
31230 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31231 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31232 this_ptr_conv.is_owned = false;
31233 int64_t ret_conv = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
31237 void __attribute__((export_name("TS_AcceptChannel_set_dust_limit_satoshis"))) TS_AcceptChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
31238 LDKAcceptChannel this_ptr_conv;
31239 this_ptr_conv.inner = untag_ptr(this_ptr);
31240 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31242 this_ptr_conv.is_owned = false;
31243 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
31246 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) {
31247 LDKAcceptChannel this_ptr_conv;
31248 this_ptr_conv.inner = untag_ptr(this_ptr);
31249 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31251 this_ptr_conv.is_owned = false;
31252 int64_t ret_conv = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
31256 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) {
31257 LDKAcceptChannel this_ptr_conv;
31258 this_ptr_conv.inner = untag_ptr(this_ptr);
31259 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31261 this_ptr_conv.is_owned = false;
31262 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
31265 int64_t __attribute__((export_name("TS_AcceptChannel_get_channel_reserve_satoshis"))) TS_AcceptChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
31266 LDKAcceptChannel this_ptr_conv;
31267 this_ptr_conv.inner = untag_ptr(this_ptr);
31268 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31270 this_ptr_conv.is_owned = false;
31271 int64_t ret_conv = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
31275 void __attribute__((export_name("TS_AcceptChannel_set_channel_reserve_satoshis"))) TS_AcceptChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
31276 LDKAcceptChannel this_ptr_conv;
31277 this_ptr_conv.inner = untag_ptr(this_ptr);
31278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31280 this_ptr_conv.is_owned = false;
31281 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
31284 int64_t __attribute__((export_name("TS_AcceptChannel_get_htlc_minimum_msat"))) TS_AcceptChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
31285 LDKAcceptChannel this_ptr_conv;
31286 this_ptr_conv.inner = untag_ptr(this_ptr);
31287 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31289 this_ptr_conv.is_owned = false;
31290 int64_t ret_conv = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
31294 void __attribute__((export_name("TS_AcceptChannel_set_htlc_minimum_msat"))) TS_AcceptChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
31295 LDKAcceptChannel this_ptr_conv;
31296 this_ptr_conv.inner = untag_ptr(this_ptr);
31297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31299 this_ptr_conv.is_owned = false;
31300 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
31303 int32_t __attribute__((export_name("TS_AcceptChannel_get_minimum_depth"))) TS_AcceptChannel_get_minimum_depth(uint64_t this_ptr) {
31304 LDKAcceptChannel this_ptr_conv;
31305 this_ptr_conv.inner = untag_ptr(this_ptr);
31306 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31308 this_ptr_conv.is_owned = false;
31309 int32_t ret_conv = AcceptChannel_get_minimum_depth(&this_ptr_conv);
31313 void __attribute__((export_name("TS_AcceptChannel_set_minimum_depth"))) TS_AcceptChannel_set_minimum_depth(uint64_t this_ptr, int32_t val) {
31314 LDKAcceptChannel this_ptr_conv;
31315 this_ptr_conv.inner = untag_ptr(this_ptr);
31316 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31318 this_ptr_conv.is_owned = false;
31319 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
31322 int16_t __attribute__((export_name("TS_AcceptChannel_get_to_self_delay"))) TS_AcceptChannel_get_to_self_delay(uint64_t this_ptr) {
31323 LDKAcceptChannel this_ptr_conv;
31324 this_ptr_conv.inner = untag_ptr(this_ptr);
31325 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31326 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31327 this_ptr_conv.is_owned = false;
31328 int16_t ret_conv = AcceptChannel_get_to_self_delay(&this_ptr_conv);
31332 void __attribute__((export_name("TS_AcceptChannel_set_to_self_delay"))) TS_AcceptChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
31333 LDKAcceptChannel this_ptr_conv;
31334 this_ptr_conv.inner = untag_ptr(this_ptr);
31335 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31337 this_ptr_conv.is_owned = false;
31338 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
31341 int16_t __attribute__((export_name("TS_AcceptChannel_get_max_accepted_htlcs"))) TS_AcceptChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
31342 LDKAcceptChannel this_ptr_conv;
31343 this_ptr_conv.inner = untag_ptr(this_ptr);
31344 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31346 this_ptr_conv.is_owned = false;
31347 int16_t ret_conv = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
31351 void __attribute__((export_name("TS_AcceptChannel_set_max_accepted_htlcs"))) TS_AcceptChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
31352 LDKAcceptChannel this_ptr_conv;
31353 this_ptr_conv.inner = untag_ptr(this_ptr);
31354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31356 this_ptr_conv.is_owned = false;
31357 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
31360 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_funding_pubkey"))) TS_AcceptChannel_get_funding_pubkey(uint64_t this_ptr) {
31361 LDKAcceptChannel this_ptr_conv;
31362 this_ptr_conv.inner = untag_ptr(this_ptr);
31363 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31365 this_ptr_conv.is_owned = false;
31366 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31367 memcpy(ret_arr->elems, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
31371 void __attribute__((export_name("TS_AcceptChannel_set_funding_pubkey"))) TS_AcceptChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
31372 LDKAcceptChannel this_ptr_conv;
31373 this_ptr_conv.inner = untag_ptr(this_ptr);
31374 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31376 this_ptr_conv.is_owned = false;
31377 LDKPublicKey val_ref;
31378 CHECK(val->arr_len == 33);
31379 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31380 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
31383 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_revocation_basepoint"))) TS_AcceptChannel_get_revocation_basepoint(uint64_t this_ptr) {
31384 LDKAcceptChannel this_ptr_conv;
31385 this_ptr_conv.inner = untag_ptr(this_ptr);
31386 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31388 this_ptr_conv.is_owned = false;
31389 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31390 memcpy(ret_arr->elems, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
31394 void __attribute__((export_name("TS_AcceptChannel_set_revocation_basepoint"))) TS_AcceptChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
31395 LDKAcceptChannel this_ptr_conv;
31396 this_ptr_conv.inner = untag_ptr(this_ptr);
31397 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31399 this_ptr_conv.is_owned = false;
31400 LDKPublicKey val_ref;
31401 CHECK(val->arr_len == 33);
31402 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31403 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
31406 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_payment_point"))) TS_AcceptChannel_get_payment_point(uint64_t this_ptr) {
31407 LDKAcceptChannel this_ptr_conv;
31408 this_ptr_conv.inner = untag_ptr(this_ptr);
31409 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31410 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31411 this_ptr_conv.is_owned = false;
31412 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31413 memcpy(ret_arr->elems, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
31417 void __attribute__((export_name("TS_AcceptChannel_set_payment_point"))) TS_AcceptChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
31418 LDKAcceptChannel this_ptr_conv;
31419 this_ptr_conv.inner = untag_ptr(this_ptr);
31420 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31421 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31422 this_ptr_conv.is_owned = false;
31423 LDKPublicKey val_ref;
31424 CHECK(val->arr_len == 33);
31425 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31426 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
31429 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_delayed_payment_basepoint"))) TS_AcceptChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
31430 LDKAcceptChannel this_ptr_conv;
31431 this_ptr_conv.inner = untag_ptr(this_ptr);
31432 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31434 this_ptr_conv.is_owned = false;
31435 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31436 memcpy(ret_arr->elems, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
31440 void __attribute__((export_name("TS_AcceptChannel_set_delayed_payment_basepoint"))) TS_AcceptChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
31441 LDKAcceptChannel this_ptr_conv;
31442 this_ptr_conv.inner = untag_ptr(this_ptr);
31443 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31444 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31445 this_ptr_conv.is_owned = false;
31446 LDKPublicKey val_ref;
31447 CHECK(val->arr_len == 33);
31448 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31449 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
31452 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_htlc_basepoint"))) TS_AcceptChannel_get_htlc_basepoint(uint64_t this_ptr) {
31453 LDKAcceptChannel this_ptr_conv;
31454 this_ptr_conv.inner = untag_ptr(this_ptr);
31455 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31456 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31457 this_ptr_conv.is_owned = false;
31458 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31459 memcpy(ret_arr->elems, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
31463 void __attribute__((export_name("TS_AcceptChannel_set_htlc_basepoint"))) TS_AcceptChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
31464 LDKAcceptChannel this_ptr_conv;
31465 this_ptr_conv.inner = untag_ptr(this_ptr);
31466 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31468 this_ptr_conv.is_owned = false;
31469 LDKPublicKey val_ref;
31470 CHECK(val->arr_len == 33);
31471 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31472 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
31475 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_first_per_commitment_point"))) TS_AcceptChannel_get_first_per_commitment_point(uint64_t this_ptr) {
31476 LDKAcceptChannel this_ptr_conv;
31477 this_ptr_conv.inner = untag_ptr(this_ptr);
31478 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31480 this_ptr_conv.is_owned = false;
31481 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31482 memcpy(ret_arr->elems, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31486 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) {
31487 LDKAcceptChannel this_ptr_conv;
31488 this_ptr_conv.inner = untag_ptr(this_ptr);
31489 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31490 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31491 this_ptr_conv.is_owned = false;
31492 LDKPublicKey val_ref;
31493 CHECK(val->arr_len == 33);
31494 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31495 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
31498 uint64_t __attribute__((export_name("TS_AcceptChannel_get_channel_type"))) TS_AcceptChannel_get_channel_type(uint64_t this_ptr) {
31499 LDKAcceptChannel this_ptr_conv;
31500 this_ptr_conv.inner = untag_ptr(this_ptr);
31501 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31503 this_ptr_conv.is_owned = false;
31504 LDKChannelTypeFeatures ret_var = AcceptChannel_get_channel_type(&this_ptr_conv);
31505 uint64_t ret_ref = 0;
31506 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31507 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31511 void __attribute__((export_name("TS_AcceptChannel_set_channel_type"))) TS_AcceptChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
31512 LDKAcceptChannel this_ptr_conv;
31513 this_ptr_conv.inner = untag_ptr(this_ptr);
31514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31516 this_ptr_conv.is_owned = false;
31517 LDKChannelTypeFeatures val_conv;
31518 val_conv.inner = untag_ptr(val);
31519 val_conv.is_owned = ptr_is_owned(val);
31520 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31521 val_conv = ChannelTypeFeatures_clone(&val_conv);
31522 AcceptChannel_set_channel_type(&this_ptr_conv, val_conv);
31525 static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
31526 LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
31527 uint64_t ret_ref = 0;
31528 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31529 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31532 int64_t __attribute__((export_name("TS_AcceptChannel_clone_ptr"))) TS_AcceptChannel_clone_ptr(uint64_t arg) {
31533 LDKAcceptChannel arg_conv;
31534 arg_conv.inner = untag_ptr(arg);
31535 arg_conv.is_owned = ptr_is_owned(arg);
31536 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31537 arg_conv.is_owned = false;
31538 int64_t ret_conv = AcceptChannel_clone_ptr(&arg_conv);
31542 uint64_t __attribute__((export_name("TS_AcceptChannel_clone"))) TS_AcceptChannel_clone(uint64_t orig) {
31543 LDKAcceptChannel orig_conv;
31544 orig_conv.inner = untag_ptr(orig);
31545 orig_conv.is_owned = ptr_is_owned(orig);
31546 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31547 orig_conv.is_owned = false;
31548 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
31549 uint64_t ret_ref = 0;
31550 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31551 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31555 jboolean __attribute__((export_name("TS_AcceptChannel_eq"))) TS_AcceptChannel_eq(uint64_t a, uint64_t b) {
31556 LDKAcceptChannel a_conv;
31557 a_conv.inner = untag_ptr(a);
31558 a_conv.is_owned = ptr_is_owned(a);
31559 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31560 a_conv.is_owned = false;
31561 LDKAcceptChannel b_conv;
31562 b_conv.inner = untag_ptr(b);
31563 b_conv.is_owned = ptr_is_owned(b);
31564 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31565 b_conv.is_owned = false;
31566 jboolean ret_conv = AcceptChannel_eq(&a_conv, &b_conv);
31570 void __attribute__((export_name("TS_FundingCreated_free"))) TS_FundingCreated_free(uint64_t this_obj) {
31571 LDKFundingCreated this_obj_conv;
31572 this_obj_conv.inner = untag_ptr(this_obj);
31573 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31575 FundingCreated_free(this_obj_conv);
31578 int8_tArray __attribute__((export_name("TS_FundingCreated_get_temporary_channel_id"))) TS_FundingCreated_get_temporary_channel_id(uint64_t this_ptr) {
31579 LDKFundingCreated this_ptr_conv;
31580 this_ptr_conv.inner = untag_ptr(this_ptr);
31581 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31582 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31583 this_ptr_conv.is_owned = false;
31584 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31585 memcpy(ret_arr->elems, *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
31589 void __attribute__((export_name("TS_FundingCreated_set_temporary_channel_id"))) TS_FundingCreated_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
31590 LDKFundingCreated this_ptr_conv;
31591 this_ptr_conv.inner = untag_ptr(this_ptr);
31592 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31594 this_ptr_conv.is_owned = false;
31595 LDKThirtyTwoBytes val_ref;
31596 CHECK(val->arr_len == 32);
31597 memcpy(val_ref.data, val->elems, 32); FREE(val);
31598 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
31601 int8_tArray __attribute__((export_name("TS_FundingCreated_get_funding_txid"))) TS_FundingCreated_get_funding_txid(uint64_t this_ptr) {
31602 LDKFundingCreated this_ptr_conv;
31603 this_ptr_conv.inner = untag_ptr(this_ptr);
31604 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31605 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31606 this_ptr_conv.is_owned = false;
31607 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31608 memcpy(ret_arr->elems, *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
31612 void __attribute__((export_name("TS_FundingCreated_set_funding_txid"))) TS_FundingCreated_set_funding_txid(uint64_t this_ptr, int8_tArray val) {
31613 LDKFundingCreated this_ptr_conv;
31614 this_ptr_conv.inner = untag_ptr(this_ptr);
31615 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31616 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31617 this_ptr_conv.is_owned = false;
31618 LDKThirtyTwoBytes val_ref;
31619 CHECK(val->arr_len == 32);
31620 memcpy(val_ref.data, val->elems, 32); FREE(val);
31621 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
31624 int16_t __attribute__((export_name("TS_FundingCreated_get_funding_output_index"))) TS_FundingCreated_get_funding_output_index(uint64_t this_ptr) {
31625 LDKFundingCreated this_ptr_conv;
31626 this_ptr_conv.inner = untag_ptr(this_ptr);
31627 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31629 this_ptr_conv.is_owned = false;
31630 int16_t ret_conv = FundingCreated_get_funding_output_index(&this_ptr_conv);
31634 void __attribute__((export_name("TS_FundingCreated_set_funding_output_index"))) TS_FundingCreated_set_funding_output_index(uint64_t this_ptr, int16_t val) {
31635 LDKFundingCreated this_ptr_conv;
31636 this_ptr_conv.inner = untag_ptr(this_ptr);
31637 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31639 this_ptr_conv.is_owned = false;
31640 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
31643 int8_tArray __attribute__((export_name("TS_FundingCreated_get_signature"))) TS_FundingCreated_get_signature(uint64_t this_ptr) {
31644 LDKFundingCreated this_ptr_conv;
31645 this_ptr_conv.inner = untag_ptr(this_ptr);
31646 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31648 this_ptr_conv.is_owned = false;
31649 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31650 memcpy(ret_arr->elems, FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
31654 void __attribute__((export_name("TS_FundingCreated_set_signature"))) TS_FundingCreated_set_signature(uint64_t this_ptr, int8_tArray val) {
31655 LDKFundingCreated this_ptr_conv;
31656 this_ptr_conv.inner = untag_ptr(this_ptr);
31657 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31658 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31659 this_ptr_conv.is_owned = false;
31660 LDKSignature val_ref;
31661 CHECK(val->arr_len == 64);
31662 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31663 FundingCreated_set_signature(&this_ptr_conv, val_ref);
31666 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) {
31667 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
31668 CHECK(temporary_channel_id_arg->arr_len == 32);
31669 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
31670 LDKThirtyTwoBytes funding_txid_arg_ref;
31671 CHECK(funding_txid_arg->arr_len == 32);
31672 memcpy(funding_txid_arg_ref.data, funding_txid_arg->elems, 32); FREE(funding_txid_arg);
31673 LDKSignature signature_arg_ref;
31674 CHECK(signature_arg->arr_len == 64);
31675 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31676 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
31677 uint64_t ret_ref = 0;
31678 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31679 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31683 static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
31684 LDKFundingCreated ret_var = FundingCreated_clone(arg);
31685 uint64_t ret_ref = 0;
31686 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31687 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31690 int64_t __attribute__((export_name("TS_FundingCreated_clone_ptr"))) TS_FundingCreated_clone_ptr(uint64_t arg) {
31691 LDKFundingCreated arg_conv;
31692 arg_conv.inner = untag_ptr(arg);
31693 arg_conv.is_owned = ptr_is_owned(arg);
31694 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31695 arg_conv.is_owned = false;
31696 int64_t ret_conv = FundingCreated_clone_ptr(&arg_conv);
31700 uint64_t __attribute__((export_name("TS_FundingCreated_clone"))) TS_FundingCreated_clone(uint64_t orig) {
31701 LDKFundingCreated orig_conv;
31702 orig_conv.inner = untag_ptr(orig);
31703 orig_conv.is_owned = ptr_is_owned(orig);
31704 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31705 orig_conv.is_owned = false;
31706 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
31707 uint64_t ret_ref = 0;
31708 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31709 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31713 jboolean __attribute__((export_name("TS_FundingCreated_eq"))) TS_FundingCreated_eq(uint64_t a, uint64_t b) {
31714 LDKFundingCreated a_conv;
31715 a_conv.inner = untag_ptr(a);
31716 a_conv.is_owned = ptr_is_owned(a);
31717 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31718 a_conv.is_owned = false;
31719 LDKFundingCreated b_conv;
31720 b_conv.inner = untag_ptr(b);
31721 b_conv.is_owned = ptr_is_owned(b);
31722 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31723 b_conv.is_owned = false;
31724 jboolean ret_conv = FundingCreated_eq(&a_conv, &b_conv);
31728 void __attribute__((export_name("TS_FundingSigned_free"))) TS_FundingSigned_free(uint64_t this_obj) {
31729 LDKFundingSigned this_obj_conv;
31730 this_obj_conv.inner = untag_ptr(this_obj);
31731 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31733 FundingSigned_free(this_obj_conv);
31736 int8_tArray __attribute__((export_name("TS_FundingSigned_get_channel_id"))) TS_FundingSigned_get_channel_id(uint64_t this_ptr) {
31737 LDKFundingSigned this_ptr_conv;
31738 this_ptr_conv.inner = untag_ptr(this_ptr);
31739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31741 this_ptr_conv.is_owned = false;
31742 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31743 memcpy(ret_arr->elems, *FundingSigned_get_channel_id(&this_ptr_conv), 32);
31747 void __attribute__((export_name("TS_FundingSigned_set_channel_id"))) TS_FundingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31748 LDKFundingSigned this_ptr_conv;
31749 this_ptr_conv.inner = untag_ptr(this_ptr);
31750 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31752 this_ptr_conv.is_owned = false;
31753 LDKThirtyTwoBytes val_ref;
31754 CHECK(val->arr_len == 32);
31755 memcpy(val_ref.data, val->elems, 32); FREE(val);
31756 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
31759 int8_tArray __attribute__((export_name("TS_FundingSigned_get_signature"))) TS_FundingSigned_get_signature(uint64_t this_ptr) {
31760 LDKFundingSigned this_ptr_conv;
31761 this_ptr_conv.inner = untag_ptr(this_ptr);
31762 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31764 this_ptr_conv.is_owned = false;
31765 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31766 memcpy(ret_arr->elems, FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
31770 void __attribute__((export_name("TS_FundingSigned_set_signature"))) TS_FundingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
31771 LDKFundingSigned this_ptr_conv;
31772 this_ptr_conv.inner = untag_ptr(this_ptr);
31773 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31775 this_ptr_conv.is_owned = false;
31776 LDKSignature val_ref;
31777 CHECK(val->arr_len == 64);
31778 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31779 FundingSigned_set_signature(&this_ptr_conv, val_ref);
31782 uint64_t __attribute__((export_name("TS_FundingSigned_new"))) TS_FundingSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg) {
31783 LDKThirtyTwoBytes channel_id_arg_ref;
31784 CHECK(channel_id_arg->arr_len == 32);
31785 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31786 LDKSignature signature_arg_ref;
31787 CHECK(signature_arg->arr_len == 64);
31788 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31789 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
31790 uint64_t ret_ref = 0;
31791 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31792 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31796 static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
31797 LDKFundingSigned ret_var = FundingSigned_clone(arg);
31798 uint64_t ret_ref = 0;
31799 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31800 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31803 int64_t __attribute__((export_name("TS_FundingSigned_clone_ptr"))) TS_FundingSigned_clone_ptr(uint64_t arg) {
31804 LDKFundingSigned arg_conv;
31805 arg_conv.inner = untag_ptr(arg);
31806 arg_conv.is_owned = ptr_is_owned(arg);
31807 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31808 arg_conv.is_owned = false;
31809 int64_t ret_conv = FundingSigned_clone_ptr(&arg_conv);
31813 uint64_t __attribute__((export_name("TS_FundingSigned_clone"))) TS_FundingSigned_clone(uint64_t orig) {
31814 LDKFundingSigned orig_conv;
31815 orig_conv.inner = untag_ptr(orig);
31816 orig_conv.is_owned = ptr_is_owned(orig);
31817 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31818 orig_conv.is_owned = false;
31819 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
31820 uint64_t ret_ref = 0;
31821 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31822 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31826 jboolean __attribute__((export_name("TS_FundingSigned_eq"))) TS_FundingSigned_eq(uint64_t a, uint64_t b) {
31827 LDKFundingSigned a_conv;
31828 a_conv.inner = untag_ptr(a);
31829 a_conv.is_owned = ptr_is_owned(a);
31830 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31831 a_conv.is_owned = false;
31832 LDKFundingSigned b_conv;
31833 b_conv.inner = untag_ptr(b);
31834 b_conv.is_owned = ptr_is_owned(b);
31835 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31836 b_conv.is_owned = false;
31837 jboolean ret_conv = FundingSigned_eq(&a_conv, &b_conv);
31841 void __attribute__((export_name("TS_ChannelReady_free"))) TS_ChannelReady_free(uint64_t this_obj) {
31842 LDKChannelReady this_obj_conv;
31843 this_obj_conv.inner = untag_ptr(this_obj);
31844 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31846 ChannelReady_free(this_obj_conv);
31849 int8_tArray __attribute__((export_name("TS_ChannelReady_get_channel_id"))) TS_ChannelReady_get_channel_id(uint64_t this_ptr) {
31850 LDKChannelReady this_ptr_conv;
31851 this_ptr_conv.inner = untag_ptr(this_ptr);
31852 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31854 this_ptr_conv.is_owned = false;
31855 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31856 memcpy(ret_arr->elems, *ChannelReady_get_channel_id(&this_ptr_conv), 32);
31860 void __attribute__((export_name("TS_ChannelReady_set_channel_id"))) TS_ChannelReady_set_channel_id(uint64_t this_ptr, int8_tArray val) {
31861 LDKChannelReady this_ptr_conv;
31862 this_ptr_conv.inner = untag_ptr(this_ptr);
31863 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31865 this_ptr_conv.is_owned = false;
31866 LDKThirtyTwoBytes val_ref;
31867 CHECK(val->arr_len == 32);
31868 memcpy(val_ref.data, val->elems, 32); FREE(val);
31869 ChannelReady_set_channel_id(&this_ptr_conv, val_ref);
31872 int8_tArray __attribute__((export_name("TS_ChannelReady_get_next_per_commitment_point"))) TS_ChannelReady_get_next_per_commitment_point(uint64_t this_ptr) {
31873 LDKChannelReady this_ptr_conv;
31874 this_ptr_conv.inner = untag_ptr(this_ptr);
31875 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31877 this_ptr_conv.is_owned = false;
31878 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31879 memcpy(ret_arr->elems, ChannelReady_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31883 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) {
31884 LDKChannelReady this_ptr_conv;
31885 this_ptr_conv.inner = untag_ptr(this_ptr);
31886 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31888 this_ptr_conv.is_owned = false;
31889 LDKPublicKey val_ref;
31890 CHECK(val->arr_len == 33);
31891 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31892 ChannelReady_set_next_per_commitment_point(&this_ptr_conv, val_ref);
31895 uint64_t __attribute__((export_name("TS_ChannelReady_get_short_channel_id_alias"))) TS_ChannelReady_get_short_channel_id_alias(uint64_t this_ptr) {
31896 LDKChannelReady this_ptr_conv;
31897 this_ptr_conv.inner = untag_ptr(this_ptr);
31898 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31900 this_ptr_conv.is_owned = false;
31901 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
31902 *ret_copy = ChannelReady_get_short_channel_id_alias(&this_ptr_conv);
31903 uint64_t ret_ref = tag_ptr(ret_copy, true);
31907 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) {
31908 LDKChannelReady this_ptr_conv;
31909 this_ptr_conv.inner = untag_ptr(this_ptr);
31910 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31911 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31912 this_ptr_conv.is_owned = false;
31913 void* val_ptr = untag_ptr(val);
31914 CHECK_ACCESS(val_ptr);
31915 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
31916 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
31917 ChannelReady_set_short_channel_id_alias(&this_ptr_conv, val_conv);
31920 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) {
31921 LDKThirtyTwoBytes channel_id_arg_ref;
31922 CHECK(channel_id_arg->arr_len == 32);
31923 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31924 LDKPublicKey next_per_commitment_point_arg_ref;
31925 CHECK(next_per_commitment_point_arg->arr_len == 33);
31926 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
31927 void* short_channel_id_alias_arg_ptr = untag_ptr(short_channel_id_alias_arg);
31928 CHECK_ACCESS(short_channel_id_alias_arg_ptr);
31929 LDKCOption_u64Z short_channel_id_alias_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_alias_arg_ptr);
31930 short_channel_id_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_alias_arg));
31931 LDKChannelReady ret_var = ChannelReady_new(channel_id_arg_ref, next_per_commitment_point_arg_ref, short_channel_id_alias_arg_conv);
31932 uint64_t ret_ref = 0;
31933 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31934 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31938 static inline uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg) {
31939 LDKChannelReady ret_var = ChannelReady_clone(arg);
31940 uint64_t ret_ref = 0;
31941 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31942 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31945 int64_t __attribute__((export_name("TS_ChannelReady_clone_ptr"))) TS_ChannelReady_clone_ptr(uint64_t arg) {
31946 LDKChannelReady arg_conv;
31947 arg_conv.inner = untag_ptr(arg);
31948 arg_conv.is_owned = ptr_is_owned(arg);
31949 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31950 arg_conv.is_owned = false;
31951 int64_t ret_conv = ChannelReady_clone_ptr(&arg_conv);
31955 uint64_t __attribute__((export_name("TS_ChannelReady_clone"))) TS_ChannelReady_clone(uint64_t orig) {
31956 LDKChannelReady orig_conv;
31957 orig_conv.inner = untag_ptr(orig);
31958 orig_conv.is_owned = ptr_is_owned(orig);
31959 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31960 orig_conv.is_owned = false;
31961 LDKChannelReady ret_var = ChannelReady_clone(&orig_conv);
31962 uint64_t ret_ref = 0;
31963 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31964 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31968 jboolean __attribute__((export_name("TS_ChannelReady_eq"))) TS_ChannelReady_eq(uint64_t a, uint64_t b) {
31969 LDKChannelReady a_conv;
31970 a_conv.inner = untag_ptr(a);
31971 a_conv.is_owned = ptr_is_owned(a);
31972 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31973 a_conv.is_owned = false;
31974 LDKChannelReady b_conv;
31975 b_conv.inner = untag_ptr(b);
31976 b_conv.is_owned = ptr_is_owned(b);
31977 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31978 b_conv.is_owned = false;
31979 jboolean ret_conv = ChannelReady_eq(&a_conv, &b_conv);
31983 void __attribute__((export_name("TS_Shutdown_free"))) TS_Shutdown_free(uint64_t this_obj) {
31984 LDKShutdown this_obj_conv;
31985 this_obj_conv.inner = untag_ptr(this_obj);
31986 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31988 Shutdown_free(this_obj_conv);
31991 int8_tArray __attribute__((export_name("TS_Shutdown_get_channel_id"))) TS_Shutdown_get_channel_id(uint64_t this_ptr) {
31992 LDKShutdown this_ptr_conv;
31993 this_ptr_conv.inner = untag_ptr(this_ptr);
31994 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31995 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31996 this_ptr_conv.is_owned = false;
31997 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31998 memcpy(ret_arr->elems, *Shutdown_get_channel_id(&this_ptr_conv), 32);
32002 void __attribute__((export_name("TS_Shutdown_set_channel_id"))) TS_Shutdown_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32003 LDKShutdown this_ptr_conv;
32004 this_ptr_conv.inner = untag_ptr(this_ptr);
32005 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32006 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32007 this_ptr_conv.is_owned = false;
32008 LDKThirtyTwoBytes val_ref;
32009 CHECK(val->arr_len == 32);
32010 memcpy(val_ref.data, val->elems, 32); FREE(val);
32011 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
32014 int8_tArray __attribute__((export_name("TS_Shutdown_get_scriptpubkey"))) TS_Shutdown_get_scriptpubkey(uint64_t this_ptr) {
32015 LDKShutdown this_ptr_conv;
32016 this_ptr_conv.inner = untag_ptr(this_ptr);
32017 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32018 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32019 this_ptr_conv.is_owned = false;
32020 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
32021 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
32022 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
32026 void __attribute__((export_name("TS_Shutdown_set_scriptpubkey"))) TS_Shutdown_set_scriptpubkey(uint64_t this_ptr, int8_tArray val) {
32027 LDKShutdown this_ptr_conv;
32028 this_ptr_conv.inner = untag_ptr(this_ptr);
32029 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32030 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32031 this_ptr_conv.is_owned = false;
32032 LDKCVec_u8Z val_ref;
32033 val_ref.datalen = val->arr_len;
32034 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
32035 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
32036 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
32039 uint64_t __attribute__((export_name("TS_Shutdown_new"))) TS_Shutdown_new(int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
32040 LDKThirtyTwoBytes channel_id_arg_ref;
32041 CHECK(channel_id_arg->arr_len == 32);
32042 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32043 LDKCVec_u8Z scriptpubkey_arg_ref;
32044 scriptpubkey_arg_ref.datalen = scriptpubkey_arg->arr_len;
32045 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
32046 memcpy(scriptpubkey_arg_ref.data, scriptpubkey_arg->elems, scriptpubkey_arg_ref.datalen); FREE(scriptpubkey_arg);
32047 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
32048 uint64_t ret_ref = 0;
32049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32054 static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
32055 LDKShutdown ret_var = Shutdown_clone(arg);
32056 uint64_t ret_ref = 0;
32057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32061 int64_t __attribute__((export_name("TS_Shutdown_clone_ptr"))) TS_Shutdown_clone_ptr(uint64_t arg) {
32062 LDKShutdown arg_conv;
32063 arg_conv.inner = untag_ptr(arg);
32064 arg_conv.is_owned = ptr_is_owned(arg);
32065 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32066 arg_conv.is_owned = false;
32067 int64_t ret_conv = Shutdown_clone_ptr(&arg_conv);
32071 uint64_t __attribute__((export_name("TS_Shutdown_clone"))) TS_Shutdown_clone(uint64_t orig) {
32072 LDKShutdown orig_conv;
32073 orig_conv.inner = untag_ptr(orig);
32074 orig_conv.is_owned = ptr_is_owned(orig);
32075 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32076 orig_conv.is_owned = false;
32077 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
32078 uint64_t ret_ref = 0;
32079 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32080 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32084 jboolean __attribute__((export_name("TS_Shutdown_eq"))) TS_Shutdown_eq(uint64_t a, uint64_t b) {
32085 LDKShutdown a_conv;
32086 a_conv.inner = untag_ptr(a);
32087 a_conv.is_owned = ptr_is_owned(a);
32088 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32089 a_conv.is_owned = false;
32090 LDKShutdown b_conv;
32091 b_conv.inner = untag_ptr(b);
32092 b_conv.is_owned = ptr_is_owned(b);
32093 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32094 b_conv.is_owned = false;
32095 jboolean ret_conv = Shutdown_eq(&a_conv, &b_conv);
32099 void __attribute__((export_name("TS_ClosingSignedFeeRange_free"))) TS_ClosingSignedFeeRange_free(uint64_t this_obj) {
32100 LDKClosingSignedFeeRange this_obj_conv;
32101 this_obj_conv.inner = untag_ptr(this_obj);
32102 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32104 ClosingSignedFeeRange_free(this_obj_conv);
32107 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_min_fee_satoshis"))) TS_ClosingSignedFeeRange_get_min_fee_satoshis(uint64_t this_ptr) {
32108 LDKClosingSignedFeeRange this_ptr_conv;
32109 this_ptr_conv.inner = untag_ptr(this_ptr);
32110 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32112 this_ptr_conv.is_owned = false;
32113 int64_t ret_conv = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
32117 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_min_fee_satoshis"))) TS_ClosingSignedFeeRange_set_min_fee_satoshis(uint64_t this_ptr, int64_t val) {
32118 LDKClosingSignedFeeRange this_ptr_conv;
32119 this_ptr_conv.inner = untag_ptr(this_ptr);
32120 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32122 this_ptr_conv.is_owned = false;
32123 ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
32126 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_max_fee_satoshis"))) TS_ClosingSignedFeeRange_get_max_fee_satoshis(uint64_t this_ptr) {
32127 LDKClosingSignedFeeRange this_ptr_conv;
32128 this_ptr_conv.inner = untag_ptr(this_ptr);
32129 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32131 this_ptr_conv.is_owned = false;
32132 int64_t ret_conv = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
32136 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_max_fee_satoshis"))) TS_ClosingSignedFeeRange_set_max_fee_satoshis(uint64_t this_ptr, int64_t val) {
32137 LDKClosingSignedFeeRange this_ptr_conv;
32138 this_ptr_conv.inner = untag_ptr(this_ptr);
32139 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32141 this_ptr_conv.is_owned = false;
32142 ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
32145 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_new"))) TS_ClosingSignedFeeRange_new(int64_t min_fee_satoshis_arg, int64_t max_fee_satoshis_arg) {
32146 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
32147 uint64_t ret_ref = 0;
32148 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32149 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32153 static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
32154 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
32155 uint64_t ret_ref = 0;
32156 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32157 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32160 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone_ptr"))) TS_ClosingSignedFeeRange_clone_ptr(uint64_t arg) {
32161 LDKClosingSignedFeeRange arg_conv;
32162 arg_conv.inner = untag_ptr(arg);
32163 arg_conv.is_owned = ptr_is_owned(arg);
32164 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32165 arg_conv.is_owned = false;
32166 int64_t ret_conv = ClosingSignedFeeRange_clone_ptr(&arg_conv);
32170 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone"))) TS_ClosingSignedFeeRange_clone(uint64_t orig) {
32171 LDKClosingSignedFeeRange orig_conv;
32172 orig_conv.inner = untag_ptr(orig);
32173 orig_conv.is_owned = ptr_is_owned(orig);
32174 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32175 orig_conv.is_owned = false;
32176 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
32177 uint64_t ret_ref = 0;
32178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32179 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32183 jboolean __attribute__((export_name("TS_ClosingSignedFeeRange_eq"))) TS_ClosingSignedFeeRange_eq(uint64_t a, uint64_t b) {
32184 LDKClosingSignedFeeRange a_conv;
32185 a_conv.inner = untag_ptr(a);
32186 a_conv.is_owned = ptr_is_owned(a);
32187 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32188 a_conv.is_owned = false;
32189 LDKClosingSignedFeeRange b_conv;
32190 b_conv.inner = untag_ptr(b);
32191 b_conv.is_owned = ptr_is_owned(b);
32192 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32193 b_conv.is_owned = false;
32194 jboolean ret_conv = ClosingSignedFeeRange_eq(&a_conv, &b_conv);
32198 void __attribute__((export_name("TS_ClosingSigned_free"))) TS_ClosingSigned_free(uint64_t this_obj) {
32199 LDKClosingSigned this_obj_conv;
32200 this_obj_conv.inner = untag_ptr(this_obj);
32201 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32202 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32203 ClosingSigned_free(this_obj_conv);
32206 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_channel_id"))) TS_ClosingSigned_get_channel_id(uint64_t this_ptr) {
32207 LDKClosingSigned this_ptr_conv;
32208 this_ptr_conv.inner = untag_ptr(this_ptr);
32209 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32211 this_ptr_conv.is_owned = false;
32212 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32213 memcpy(ret_arr->elems, *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
32217 void __attribute__((export_name("TS_ClosingSigned_set_channel_id"))) TS_ClosingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32218 LDKClosingSigned this_ptr_conv;
32219 this_ptr_conv.inner = untag_ptr(this_ptr);
32220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32222 this_ptr_conv.is_owned = false;
32223 LDKThirtyTwoBytes val_ref;
32224 CHECK(val->arr_len == 32);
32225 memcpy(val_ref.data, val->elems, 32); FREE(val);
32226 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
32229 int64_t __attribute__((export_name("TS_ClosingSigned_get_fee_satoshis"))) TS_ClosingSigned_get_fee_satoshis(uint64_t this_ptr) {
32230 LDKClosingSigned this_ptr_conv;
32231 this_ptr_conv.inner = untag_ptr(this_ptr);
32232 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32234 this_ptr_conv.is_owned = false;
32235 int64_t ret_conv = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
32239 void __attribute__((export_name("TS_ClosingSigned_set_fee_satoshis"))) TS_ClosingSigned_set_fee_satoshis(uint64_t this_ptr, int64_t val) {
32240 LDKClosingSigned this_ptr_conv;
32241 this_ptr_conv.inner = untag_ptr(this_ptr);
32242 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32244 this_ptr_conv.is_owned = false;
32245 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
32248 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_signature"))) TS_ClosingSigned_get_signature(uint64_t this_ptr) {
32249 LDKClosingSigned this_ptr_conv;
32250 this_ptr_conv.inner = untag_ptr(this_ptr);
32251 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32253 this_ptr_conv.is_owned = false;
32254 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32255 memcpy(ret_arr->elems, ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
32259 void __attribute__((export_name("TS_ClosingSigned_set_signature"))) TS_ClosingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
32260 LDKClosingSigned this_ptr_conv;
32261 this_ptr_conv.inner = untag_ptr(this_ptr);
32262 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32264 this_ptr_conv.is_owned = false;
32265 LDKSignature val_ref;
32266 CHECK(val->arr_len == 64);
32267 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32268 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
32271 uint64_t __attribute__((export_name("TS_ClosingSigned_get_fee_range"))) TS_ClosingSigned_get_fee_range(uint64_t this_ptr) {
32272 LDKClosingSigned this_ptr_conv;
32273 this_ptr_conv.inner = untag_ptr(this_ptr);
32274 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32276 this_ptr_conv.is_owned = false;
32277 LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
32278 uint64_t ret_ref = 0;
32279 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32280 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32284 void __attribute__((export_name("TS_ClosingSigned_set_fee_range"))) TS_ClosingSigned_set_fee_range(uint64_t this_ptr, uint64_t val) {
32285 LDKClosingSigned this_ptr_conv;
32286 this_ptr_conv.inner = untag_ptr(this_ptr);
32287 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32289 this_ptr_conv.is_owned = false;
32290 LDKClosingSignedFeeRange val_conv;
32291 val_conv.inner = untag_ptr(val);
32292 val_conv.is_owned = ptr_is_owned(val);
32293 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
32294 val_conv = ClosingSignedFeeRange_clone(&val_conv);
32295 ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
32298 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) {
32299 LDKThirtyTwoBytes channel_id_arg_ref;
32300 CHECK(channel_id_arg->arr_len == 32);
32301 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32302 LDKSignature signature_arg_ref;
32303 CHECK(signature_arg->arr_len == 64);
32304 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
32305 LDKClosingSignedFeeRange fee_range_arg_conv;
32306 fee_range_arg_conv.inner = untag_ptr(fee_range_arg);
32307 fee_range_arg_conv.is_owned = ptr_is_owned(fee_range_arg);
32308 CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
32309 fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
32310 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
32311 uint64_t ret_ref = 0;
32312 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32313 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32317 static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
32318 LDKClosingSigned ret_var = ClosingSigned_clone(arg);
32319 uint64_t ret_ref = 0;
32320 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32321 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32324 int64_t __attribute__((export_name("TS_ClosingSigned_clone_ptr"))) TS_ClosingSigned_clone_ptr(uint64_t arg) {
32325 LDKClosingSigned arg_conv;
32326 arg_conv.inner = untag_ptr(arg);
32327 arg_conv.is_owned = ptr_is_owned(arg);
32328 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32329 arg_conv.is_owned = false;
32330 int64_t ret_conv = ClosingSigned_clone_ptr(&arg_conv);
32334 uint64_t __attribute__((export_name("TS_ClosingSigned_clone"))) TS_ClosingSigned_clone(uint64_t orig) {
32335 LDKClosingSigned orig_conv;
32336 orig_conv.inner = untag_ptr(orig);
32337 orig_conv.is_owned = ptr_is_owned(orig);
32338 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32339 orig_conv.is_owned = false;
32340 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
32341 uint64_t ret_ref = 0;
32342 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32343 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32347 jboolean __attribute__((export_name("TS_ClosingSigned_eq"))) TS_ClosingSigned_eq(uint64_t a, uint64_t b) {
32348 LDKClosingSigned a_conv;
32349 a_conv.inner = untag_ptr(a);
32350 a_conv.is_owned = ptr_is_owned(a);
32351 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32352 a_conv.is_owned = false;
32353 LDKClosingSigned b_conv;
32354 b_conv.inner = untag_ptr(b);
32355 b_conv.is_owned = ptr_is_owned(b);
32356 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32357 b_conv.is_owned = false;
32358 jboolean ret_conv = ClosingSigned_eq(&a_conv, &b_conv);
32362 void __attribute__((export_name("TS_UpdateAddHTLC_free"))) TS_UpdateAddHTLC_free(uint64_t this_obj) {
32363 LDKUpdateAddHTLC this_obj_conv;
32364 this_obj_conv.inner = untag_ptr(this_obj);
32365 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32367 UpdateAddHTLC_free(this_obj_conv);
32370 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_channel_id"))) TS_UpdateAddHTLC_get_channel_id(uint64_t this_ptr) {
32371 LDKUpdateAddHTLC this_ptr_conv;
32372 this_ptr_conv.inner = untag_ptr(this_ptr);
32373 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32375 this_ptr_conv.is_owned = false;
32376 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32377 memcpy(ret_arr->elems, *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
32381 void __attribute__((export_name("TS_UpdateAddHTLC_set_channel_id"))) TS_UpdateAddHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32382 LDKUpdateAddHTLC this_ptr_conv;
32383 this_ptr_conv.inner = untag_ptr(this_ptr);
32384 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32386 this_ptr_conv.is_owned = false;
32387 LDKThirtyTwoBytes val_ref;
32388 CHECK(val->arr_len == 32);
32389 memcpy(val_ref.data, val->elems, 32); FREE(val);
32390 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
32393 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_htlc_id"))) TS_UpdateAddHTLC_get_htlc_id(uint64_t this_ptr) {
32394 LDKUpdateAddHTLC this_ptr_conv;
32395 this_ptr_conv.inner = untag_ptr(this_ptr);
32396 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32398 this_ptr_conv.is_owned = false;
32399 int64_t ret_conv = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
32403 void __attribute__((export_name("TS_UpdateAddHTLC_set_htlc_id"))) TS_UpdateAddHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32404 LDKUpdateAddHTLC this_ptr_conv;
32405 this_ptr_conv.inner = untag_ptr(this_ptr);
32406 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32408 this_ptr_conv.is_owned = false;
32409 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
32412 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_amount_msat"))) TS_UpdateAddHTLC_get_amount_msat(uint64_t this_ptr) {
32413 LDKUpdateAddHTLC this_ptr_conv;
32414 this_ptr_conv.inner = untag_ptr(this_ptr);
32415 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32417 this_ptr_conv.is_owned = false;
32418 int64_t ret_conv = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
32422 void __attribute__((export_name("TS_UpdateAddHTLC_set_amount_msat"))) TS_UpdateAddHTLC_set_amount_msat(uint64_t this_ptr, int64_t val) {
32423 LDKUpdateAddHTLC this_ptr_conv;
32424 this_ptr_conv.inner = untag_ptr(this_ptr);
32425 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32427 this_ptr_conv.is_owned = false;
32428 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
32431 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_payment_hash"))) TS_UpdateAddHTLC_get_payment_hash(uint64_t this_ptr) {
32432 LDKUpdateAddHTLC this_ptr_conv;
32433 this_ptr_conv.inner = untag_ptr(this_ptr);
32434 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32436 this_ptr_conv.is_owned = false;
32437 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32438 memcpy(ret_arr->elems, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
32442 void __attribute__((export_name("TS_UpdateAddHTLC_set_payment_hash"))) TS_UpdateAddHTLC_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
32443 LDKUpdateAddHTLC this_ptr_conv;
32444 this_ptr_conv.inner = untag_ptr(this_ptr);
32445 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32447 this_ptr_conv.is_owned = false;
32448 LDKThirtyTwoBytes val_ref;
32449 CHECK(val->arr_len == 32);
32450 memcpy(val_ref.data, val->elems, 32); FREE(val);
32451 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
32454 int32_t __attribute__((export_name("TS_UpdateAddHTLC_get_cltv_expiry"))) TS_UpdateAddHTLC_get_cltv_expiry(uint64_t this_ptr) {
32455 LDKUpdateAddHTLC this_ptr_conv;
32456 this_ptr_conv.inner = untag_ptr(this_ptr);
32457 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32459 this_ptr_conv.is_owned = false;
32460 int32_t ret_conv = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
32464 void __attribute__((export_name("TS_UpdateAddHTLC_set_cltv_expiry"))) TS_UpdateAddHTLC_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
32465 LDKUpdateAddHTLC this_ptr_conv;
32466 this_ptr_conv.inner = untag_ptr(this_ptr);
32467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32469 this_ptr_conv.is_owned = false;
32470 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
32473 static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
32474 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
32475 uint64_t ret_ref = 0;
32476 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32477 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32480 int64_t __attribute__((export_name("TS_UpdateAddHTLC_clone_ptr"))) TS_UpdateAddHTLC_clone_ptr(uint64_t arg) {
32481 LDKUpdateAddHTLC arg_conv;
32482 arg_conv.inner = untag_ptr(arg);
32483 arg_conv.is_owned = ptr_is_owned(arg);
32484 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32485 arg_conv.is_owned = false;
32486 int64_t ret_conv = UpdateAddHTLC_clone_ptr(&arg_conv);
32490 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_clone"))) TS_UpdateAddHTLC_clone(uint64_t orig) {
32491 LDKUpdateAddHTLC orig_conv;
32492 orig_conv.inner = untag_ptr(orig);
32493 orig_conv.is_owned = ptr_is_owned(orig);
32494 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32495 orig_conv.is_owned = false;
32496 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
32497 uint64_t ret_ref = 0;
32498 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32499 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32503 jboolean __attribute__((export_name("TS_UpdateAddHTLC_eq"))) TS_UpdateAddHTLC_eq(uint64_t a, uint64_t b) {
32504 LDKUpdateAddHTLC a_conv;
32505 a_conv.inner = untag_ptr(a);
32506 a_conv.is_owned = ptr_is_owned(a);
32507 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32508 a_conv.is_owned = false;
32509 LDKUpdateAddHTLC b_conv;
32510 b_conv.inner = untag_ptr(b);
32511 b_conv.is_owned = ptr_is_owned(b);
32512 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32513 b_conv.is_owned = false;
32514 jboolean ret_conv = UpdateAddHTLC_eq(&a_conv, &b_conv);
32518 void __attribute__((export_name("TS_OnionMessage_free"))) TS_OnionMessage_free(uint64_t this_obj) {
32519 LDKOnionMessage this_obj_conv;
32520 this_obj_conv.inner = untag_ptr(this_obj);
32521 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32523 OnionMessage_free(this_obj_conv);
32526 int8_tArray __attribute__((export_name("TS_OnionMessage_get_blinding_point"))) TS_OnionMessage_get_blinding_point(uint64_t this_ptr) {
32527 LDKOnionMessage this_ptr_conv;
32528 this_ptr_conv.inner = untag_ptr(this_ptr);
32529 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32531 this_ptr_conv.is_owned = false;
32532 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
32533 memcpy(ret_arr->elems, OnionMessage_get_blinding_point(&this_ptr_conv).compressed_form, 33);
32537 void __attribute__((export_name("TS_OnionMessage_set_blinding_point"))) TS_OnionMessage_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
32538 LDKOnionMessage this_ptr_conv;
32539 this_ptr_conv.inner = untag_ptr(this_ptr);
32540 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32542 this_ptr_conv.is_owned = false;
32543 LDKPublicKey val_ref;
32544 CHECK(val->arr_len == 33);
32545 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
32546 OnionMessage_set_blinding_point(&this_ptr_conv, val_ref);
32549 static inline uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg) {
32550 LDKOnionMessage ret_var = OnionMessage_clone(arg);
32551 uint64_t ret_ref = 0;
32552 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32553 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32556 int64_t __attribute__((export_name("TS_OnionMessage_clone_ptr"))) TS_OnionMessage_clone_ptr(uint64_t arg) {
32557 LDKOnionMessage arg_conv;
32558 arg_conv.inner = untag_ptr(arg);
32559 arg_conv.is_owned = ptr_is_owned(arg);
32560 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32561 arg_conv.is_owned = false;
32562 int64_t ret_conv = OnionMessage_clone_ptr(&arg_conv);
32566 uint64_t __attribute__((export_name("TS_OnionMessage_clone"))) TS_OnionMessage_clone(uint64_t orig) {
32567 LDKOnionMessage orig_conv;
32568 orig_conv.inner = untag_ptr(orig);
32569 orig_conv.is_owned = ptr_is_owned(orig);
32570 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32571 orig_conv.is_owned = false;
32572 LDKOnionMessage ret_var = OnionMessage_clone(&orig_conv);
32573 uint64_t ret_ref = 0;
32574 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32575 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32579 jboolean __attribute__((export_name("TS_OnionMessage_eq"))) TS_OnionMessage_eq(uint64_t a, uint64_t b) {
32580 LDKOnionMessage a_conv;
32581 a_conv.inner = untag_ptr(a);
32582 a_conv.is_owned = ptr_is_owned(a);
32583 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32584 a_conv.is_owned = false;
32585 LDKOnionMessage b_conv;
32586 b_conv.inner = untag_ptr(b);
32587 b_conv.is_owned = ptr_is_owned(b);
32588 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32589 b_conv.is_owned = false;
32590 jboolean ret_conv = OnionMessage_eq(&a_conv, &b_conv);
32594 void __attribute__((export_name("TS_UpdateFulfillHTLC_free"))) TS_UpdateFulfillHTLC_free(uint64_t this_obj) {
32595 LDKUpdateFulfillHTLC this_obj_conv;
32596 this_obj_conv.inner = untag_ptr(this_obj);
32597 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32599 UpdateFulfillHTLC_free(this_obj_conv);
32602 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_channel_id"))) TS_UpdateFulfillHTLC_get_channel_id(uint64_t this_ptr) {
32603 LDKUpdateFulfillHTLC this_ptr_conv;
32604 this_ptr_conv.inner = untag_ptr(this_ptr);
32605 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32607 this_ptr_conv.is_owned = false;
32608 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32609 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
32613 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_channel_id"))) TS_UpdateFulfillHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32614 LDKUpdateFulfillHTLC this_ptr_conv;
32615 this_ptr_conv.inner = untag_ptr(this_ptr);
32616 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32617 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32618 this_ptr_conv.is_owned = false;
32619 LDKThirtyTwoBytes val_ref;
32620 CHECK(val->arr_len == 32);
32621 memcpy(val_ref.data, val->elems, 32); FREE(val);
32622 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
32625 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_get_htlc_id"))) TS_UpdateFulfillHTLC_get_htlc_id(uint64_t this_ptr) {
32626 LDKUpdateFulfillHTLC this_ptr_conv;
32627 this_ptr_conv.inner = untag_ptr(this_ptr);
32628 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32630 this_ptr_conv.is_owned = false;
32631 int64_t ret_conv = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
32635 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_htlc_id"))) TS_UpdateFulfillHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32636 LDKUpdateFulfillHTLC this_ptr_conv;
32637 this_ptr_conv.inner = untag_ptr(this_ptr);
32638 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32640 this_ptr_conv.is_owned = false;
32641 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
32644 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_payment_preimage"))) TS_UpdateFulfillHTLC_get_payment_preimage(uint64_t this_ptr) {
32645 LDKUpdateFulfillHTLC this_ptr_conv;
32646 this_ptr_conv.inner = untag_ptr(this_ptr);
32647 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32649 this_ptr_conv.is_owned = false;
32650 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32651 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
32655 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_payment_preimage"))) TS_UpdateFulfillHTLC_set_payment_preimage(uint64_t this_ptr, int8_tArray val) {
32656 LDKUpdateFulfillHTLC this_ptr_conv;
32657 this_ptr_conv.inner = untag_ptr(this_ptr);
32658 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32659 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32660 this_ptr_conv.is_owned = false;
32661 LDKThirtyTwoBytes val_ref;
32662 CHECK(val->arr_len == 32);
32663 memcpy(val_ref.data, val->elems, 32); FREE(val);
32664 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
32667 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) {
32668 LDKThirtyTwoBytes channel_id_arg_ref;
32669 CHECK(channel_id_arg->arr_len == 32);
32670 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
32671 LDKThirtyTwoBytes payment_preimage_arg_ref;
32672 CHECK(payment_preimage_arg->arr_len == 32);
32673 memcpy(payment_preimage_arg_ref.data, payment_preimage_arg->elems, 32); FREE(payment_preimage_arg);
32674 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
32675 uint64_t ret_ref = 0;
32676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32677 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32681 static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
32682 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
32683 uint64_t ret_ref = 0;
32684 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32685 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32688 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone_ptr"))) TS_UpdateFulfillHTLC_clone_ptr(uint64_t arg) {
32689 LDKUpdateFulfillHTLC arg_conv;
32690 arg_conv.inner = untag_ptr(arg);
32691 arg_conv.is_owned = ptr_is_owned(arg);
32692 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32693 arg_conv.is_owned = false;
32694 int64_t ret_conv = UpdateFulfillHTLC_clone_ptr(&arg_conv);
32698 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone"))) TS_UpdateFulfillHTLC_clone(uint64_t orig) {
32699 LDKUpdateFulfillHTLC orig_conv;
32700 orig_conv.inner = untag_ptr(orig);
32701 orig_conv.is_owned = ptr_is_owned(orig);
32702 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32703 orig_conv.is_owned = false;
32704 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
32705 uint64_t ret_ref = 0;
32706 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32707 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32711 jboolean __attribute__((export_name("TS_UpdateFulfillHTLC_eq"))) TS_UpdateFulfillHTLC_eq(uint64_t a, uint64_t b) {
32712 LDKUpdateFulfillHTLC a_conv;
32713 a_conv.inner = untag_ptr(a);
32714 a_conv.is_owned = ptr_is_owned(a);
32715 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32716 a_conv.is_owned = false;
32717 LDKUpdateFulfillHTLC b_conv;
32718 b_conv.inner = untag_ptr(b);
32719 b_conv.is_owned = ptr_is_owned(b);
32720 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32721 b_conv.is_owned = false;
32722 jboolean ret_conv = UpdateFulfillHTLC_eq(&a_conv, &b_conv);
32726 void __attribute__((export_name("TS_UpdateFailHTLC_free"))) TS_UpdateFailHTLC_free(uint64_t this_obj) {
32727 LDKUpdateFailHTLC this_obj_conv;
32728 this_obj_conv.inner = untag_ptr(this_obj);
32729 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32731 UpdateFailHTLC_free(this_obj_conv);
32734 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_get_channel_id"))) TS_UpdateFailHTLC_get_channel_id(uint64_t this_ptr) {
32735 LDKUpdateFailHTLC this_ptr_conv;
32736 this_ptr_conv.inner = untag_ptr(this_ptr);
32737 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32739 this_ptr_conv.is_owned = false;
32740 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32741 memcpy(ret_arr->elems, *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
32745 void __attribute__((export_name("TS_UpdateFailHTLC_set_channel_id"))) TS_UpdateFailHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32746 LDKUpdateFailHTLC this_ptr_conv;
32747 this_ptr_conv.inner = untag_ptr(this_ptr);
32748 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32749 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32750 this_ptr_conv.is_owned = false;
32751 LDKThirtyTwoBytes val_ref;
32752 CHECK(val->arr_len == 32);
32753 memcpy(val_ref.data, val->elems, 32); FREE(val);
32754 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
32757 int64_t __attribute__((export_name("TS_UpdateFailHTLC_get_htlc_id"))) TS_UpdateFailHTLC_get_htlc_id(uint64_t this_ptr) {
32758 LDKUpdateFailHTLC this_ptr_conv;
32759 this_ptr_conv.inner = untag_ptr(this_ptr);
32760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32762 this_ptr_conv.is_owned = false;
32763 int64_t ret_conv = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
32767 void __attribute__((export_name("TS_UpdateFailHTLC_set_htlc_id"))) TS_UpdateFailHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32768 LDKUpdateFailHTLC this_ptr_conv;
32769 this_ptr_conv.inner = untag_ptr(this_ptr);
32770 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32772 this_ptr_conv.is_owned = false;
32773 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
32776 static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
32777 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
32778 uint64_t ret_ref = 0;
32779 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32780 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32783 int64_t __attribute__((export_name("TS_UpdateFailHTLC_clone_ptr"))) TS_UpdateFailHTLC_clone_ptr(uint64_t arg) {
32784 LDKUpdateFailHTLC arg_conv;
32785 arg_conv.inner = untag_ptr(arg);
32786 arg_conv.is_owned = ptr_is_owned(arg);
32787 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32788 arg_conv.is_owned = false;
32789 int64_t ret_conv = UpdateFailHTLC_clone_ptr(&arg_conv);
32793 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_clone"))) TS_UpdateFailHTLC_clone(uint64_t orig) {
32794 LDKUpdateFailHTLC orig_conv;
32795 orig_conv.inner = untag_ptr(orig);
32796 orig_conv.is_owned = ptr_is_owned(orig);
32797 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32798 orig_conv.is_owned = false;
32799 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
32800 uint64_t ret_ref = 0;
32801 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32802 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32806 jboolean __attribute__((export_name("TS_UpdateFailHTLC_eq"))) TS_UpdateFailHTLC_eq(uint64_t a, uint64_t b) {
32807 LDKUpdateFailHTLC a_conv;
32808 a_conv.inner = untag_ptr(a);
32809 a_conv.is_owned = ptr_is_owned(a);
32810 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32811 a_conv.is_owned = false;
32812 LDKUpdateFailHTLC b_conv;
32813 b_conv.inner = untag_ptr(b);
32814 b_conv.is_owned = ptr_is_owned(b);
32815 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32816 b_conv.is_owned = false;
32817 jboolean ret_conv = UpdateFailHTLC_eq(&a_conv, &b_conv);
32821 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_free"))) TS_UpdateFailMalformedHTLC_free(uint64_t this_obj) {
32822 LDKUpdateFailMalformedHTLC this_obj_conv;
32823 this_obj_conv.inner = untag_ptr(this_obj);
32824 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32826 UpdateFailMalformedHTLC_free(this_obj_conv);
32829 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_channel_id"))) TS_UpdateFailMalformedHTLC_get_channel_id(uint64_t this_ptr) {
32830 LDKUpdateFailMalformedHTLC this_ptr_conv;
32831 this_ptr_conv.inner = untag_ptr(this_ptr);
32832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32834 this_ptr_conv.is_owned = false;
32835 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32836 memcpy(ret_arr->elems, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
32840 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_channel_id"))) TS_UpdateFailMalformedHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32841 LDKUpdateFailMalformedHTLC this_ptr_conv;
32842 this_ptr_conv.inner = untag_ptr(this_ptr);
32843 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32844 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32845 this_ptr_conv.is_owned = false;
32846 LDKThirtyTwoBytes val_ref;
32847 CHECK(val->arr_len == 32);
32848 memcpy(val_ref.data, val->elems, 32); FREE(val);
32849 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
32852 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_htlc_id"))) TS_UpdateFailMalformedHTLC_get_htlc_id(uint64_t this_ptr) {
32853 LDKUpdateFailMalformedHTLC this_ptr_conv;
32854 this_ptr_conv.inner = untag_ptr(this_ptr);
32855 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32857 this_ptr_conv.is_owned = false;
32858 int64_t ret_conv = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
32862 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_htlc_id"))) TS_UpdateFailMalformedHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
32863 LDKUpdateFailMalformedHTLC this_ptr_conv;
32864 this_ptr_conv.inner = untag_ptr(this_ptr);
32865 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32867 this_ptr_conv.is_owned = false;
32868 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
32871 int16_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_failure_code"))) TS_UpdateFailMalformedHTLC_get_failure_code(uint64_t this_ptr) {
32872 LDKUpdateFailMalformedHTLC this_ptr_conv;
32873 this_ptr_conv.inner = untag_ptr(this_ptr);
32874 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32876 this_ptr_conv.is_owned = false;
32877 int16_t ret_conv = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
32881 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_failure_code"))) TS_UpdateFailMalformedHTLC_set_failure_code(uint64_t this_ptr, int16_t val) {
32882 LDKUpdateFailMalformedHTLC this_ptr_conv;
32883 this_ptr_conv.inner = untag_ptr(this_ptr);
32884 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32886 this_ptr_conv.is_owned = false;
32887 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
32890 static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
32891 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
32892 uint64_t ret_ref = 0;
32893 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32894 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32897 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone_ptr"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint64_t arg) {
32898 LDKUpdateFailMalformedHTLC arg_conv;
32899 arg_conv.inner = untag_ptr(arg);
32900 arg_conv.is_owned = ptr_is_owned(arg);
32901 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32902 arg_conv.is_owned = false;
32903 int64_t ret_conv = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
32907 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone"))) TS_UpdateFailMalformedHTLC_clone(uint64_t orig) {
32908 LDKUpdateFailMalformedHTLC orig_conv;
32909 orig_conv.inner = untag_ptr(orig);
32910 orig_conv.is_owned = ptr_is_owned(orig);
32911 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32912 orig_conv.is_owned = false;
32913 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
32914 uint64_t ret_ref = 0;
32915 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32916 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32920 jboolean __attribute__((export_name("TS_UpdateFailMalformedHTLC_eq"))) TS_UpdateFailMalformedHTLC_eq(uint64_t a, uint64_t b) {
32921 LDKUpdateFailMalformedHTLC a_conv;
32922 a_conv.inner = untag_ptr(a);
32923 a_conv.is_owned = ptr_is_owned(a);
32924 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32925 a_conv.is_owned = false;
32926 LDKUpdateFailMalformedHTLC b_conv;
32927 b_conv.inner = untag_ptr(b);
32928 b_conv.is_owned = ptr_is_owned(b);
32929 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32930 b_conv.is_owned = false;
32931 jboolean ret_conv = UpdateFailMalformedHTLC_eq(&a_conv, &b_conv);
32935 void __attribute__((export_name("TS_CommitmentSigned_free"))) TS_CommitmentSigned_free(uint64_t this_obj) {
32936 LDKCommitmentSigned this_obj_conv;
32937 this_obj_conv.inner = untag_ptr(this_obj);
32938 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32939 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32940 CommitmentSigned_free(this_obj_conv);
32943 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_channel_id"))) TS_CommitmentSigned_get_channel_id(uint64_t this_ptr) {
32944 LDKCommitmentSigned this_ptr_conv;
32945 this_ptr_conv.inner = untag_ptr(this_ptr);
32946 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32948 this_ptr_conv.is_owned = false;
32949 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32950 memcpy(ret_arr->elems, *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
32954 void __attribute__((export_name("TS_CommitmentSigned_set_channel_id"))) TS_CommitmentSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
32955 LDKCommitmentSigned this_ptr_conv;
32956 this_ptr_conv.inner = untag_ptr(this_ptr);
32957 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32959 this_ptr_conv.is_owned = false;
32960 LDKThirtyTwoBytes val_ref;
32961 CHECK(val->arr_len == 32);
32962 memcpy(val_ref.data, val->elems, 32); FREE(val);
32963 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
32966 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_signature"))) TS_CommitmentSigned_get_signature(uint64_t this_ptr) {
32967 LDKCommitmentSigned this_ptr_conv;
32968 this_ptr_conv.inner = untag_ptr(this_ptr);
32969 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32971 this_ptr_conv.is_owned = false;
32972 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32973 memcpy(ret_arr->elems, CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
32977 void __attribute__((export_name("TS_CommitmentSigned_set_signature"))) TS_CommitmentSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
32978 LDKCommitmentSigned this_ptr_conv;
32979 this_ptr_conv.inner = untag_ptr(this_ptr);
32980 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32982 this_ptr_conv.is_owned = false;
32983 LDKSignature val_ref;
32984 CHECK(val->arr_len == 64);
32985 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32986 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
32989 ptrArray __attribute__((export_name("TS_CommitmentSigned_get_htlc_signatures"))) TS_CommitmentSigned_get_htlc_signatures(uint64_t this_ptr) {
32990 LDKCommitmentSigned this_ptr_conv;
32991 this_ptr_conv.inner = untag_ptr(this_ptr);
32992 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32994 this_ptr_conv.is_owned = false;
32995 LDKCVec_SignatureZ ret_var = CommitmentSigned_get_htlc_signatures(&this_ptr_conv);
32996 ptrArray ret_arr = NULL;
32997 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
32998 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
32999 for (size_t m = 0; m < ret_var.datalen; m++) {
33000 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
33001 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
33002 ret_arr_ptr[m] = ret_conv_12_arr;
33005 FREE(ret_var.data);
33009 void __attribute__((export_name("TS_CommitmentSigned_set_htlc_signatures"))) TS_CommitmentSigned_set_htlc_signatures(uint64_t this_ptr, ptrArray val) {
33010 LDKCommitmentSigned this_ptr_conv;
33011 this_ptr_conv.inner = untag_ptr(this_ptr);
33012 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33014 this_ptr_conv.is_owned = false;
33015 LDKCVec_SignatureZ val_constr;
33016 val_constr.datalen = val->arr_len;
33017 if (val_constr.datalen > 0)
33018 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
33020 val_constr.data = NULL;
33021 int8_tArray* val_vals = (void*) val->elems;
33022 for (size_t m = 0; m < val_constr.datalen; m++) {
33023 int8_tArray val_conv_12 = val_vals[m];
33024 LDKSignature val_conv_12_ref;
33025 CHECK(val_conv_12->arr_len == 64);
33026 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
33027 val_constr.data[m] = val_conv_12_ref;
33030 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
33033 uint64_t __attribute__((export_name("TS_CommitmentSigned_new"))) TS_CommitmentSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg, ptrArray htlc_signatures_arg) {
33034 LDKThirtyTwoBytes channel_id_arg_ref;
33035 CHECK(channel_id_arg->arr_len == 32);
33036 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33037 LDKSignature signature_arg_ref;
33038 CHECK(signature_arg->arr_len == 64);
33039 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
33040 LDKCVec_SignatureZ htlc_signatures_arg_constr;
33041 htlc_signatures_arg_constr.datalen = htlc_signatures_arg->arr_len;
33042 if (htlc_signatures_arg_constr.datalen > 0)
33043 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
33045 htlc_signatures_arg_constr.data = NULL;
33046 int8_tArray* htlc_signatures_arg_vals = (void*) htlc_signatures_arg->elems;
33047 for (size_t m = 0; m < htlc_signatures_arg_constr.datalen; m++) {
33048 int8_tArray htlc_signatures_arg_conv_12 = htlc_signatures_arg_vals[m];
33049 LDKSignature htlc_signatures_arg_conv_12_ref;
33050 CHECK(htlc_signatures_arg_conv_12->arr_len == 64);
33051 memcpy(htlc_signatures_arg_conv_12_ref.compact_form, htlc_signatures_arg_conv_12->elems, 64); FREE(htlc_signatures_arg_conv_12);
33052 htlc_signatures_arg_constr.data[m] = htlc_signatures_arg_conv_12_ref;
33054 FREE(htlc_signatures_arg);
33055 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
33056 uint64_t ret_ref = 0;
33057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33062 static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
33063 LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
33064 uint64_t ret_ref = 0;
33065 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33066 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33069 int64_t __attribute__((export_name("TS_CommitmentSigned_clone_ptr"))) TS_CommitmentSigned_clone_ptr(uint64_t arg) {
33070 LDKCommitmentSigned arg_conv;
33071 arg_conv.inner = untag_ptr(arg);
33072 arg_conv.is_owned = ptr_is_owned(arg);
33073 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33074 arg_conv.is_owned = false;
33075 int64_t ret_conv = CommitmentSigned_clone_ptr(&arg_conv);
33079 uint64_t __attribute__((export_name("TS_CommitmentSigned_clone"))) TS_CommitmentSigned_clone(uint64_t orig) {
33080 LDKCommitmentSigned orig_conv;
33081 orig_conv.inner = untag_ptr(orig);
33082 orig_conv.is_owned = ptr_is_owned(orig);
33083 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33084 orig_conv.is_owned = false;
33085 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
33086 uint64_t ret_ref = 0;
33087 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33088 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33092 jboolean __attribute__((export_name("TS_CommitmentSigned_eq"))) TS_CommitmentSigned_eq(uint64_t a, uint64_t b) {
33093 LDKCommitmentSigned a_conv;
33094 a_conv.inner = untag_ptr(a);
33095 a_conv.is_owned = ptr_is_owned(a);
33096 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33097 a_conv.is_owned = false;
33098 LDKCommitmentSigned b_conv;
33099 b_conv.inner = untag_ptr(b);
33100 b_conv.is_owned = ptr_is_owned(b);
33101 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33102 b_conv.is_owned = false;
33103 jboolean ret_conv = CommitmentSigned_eq(&a_conv, &b_conv);
33107 void __attribute__((export_name("TS_RevokeAndACK_free"))) TS_RevokeAndACK_free(uint64_t this_obj) {
33108 LDKRevokeAndACK this_obj_conv;
33109 this_obj_conv.inner = untag_ptr(this_obj);
33110 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33112 RevokeAndACK_free(this_obj_conv);
33115 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_channel_id"))) TS_RevokeAndACK_get_channel_id(uint64_t this_ptr) {
33116 LDKRevokeAndACK this_ptr_conv;
33117 this_ptr_conv.inner = untag_ptr(this_ptr);
33118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33120 this_ptr_conv.is_owned = false;
33121 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33122 memcpy(ret_arr->elems, *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
33126 void __attribute__((export_name("TS_RevokeAndACK_set_channel_id"))) TS_RevokeAndACK_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33127 LDKRevokeAndACK this_ptr_conv;
33128 this_ptr_conv.inner = untag_ptr(this_ptr);
33129 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33131 this_ptr_conv.is_owned = false;
33132 LDKThirtyTwoBytes val_ref;
33133 CHECK(val->arr_len == 32);
33134 memcpy(val_ref.data, val->elems, 32); FREE(val);
33135 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
33138 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_per_commitment_secret"))) TS_RevokeAndACK_get_per_commitment_secret(uint64_t this_ptr) {
33139 LDKRevokeAndACK this_ptr_conv;
33140 this_ptr_conv.inner = untag_ptr(this_ptr);
33141 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33143 this_ptr_conv.is_owned = false;
33144 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33145 memcpy(ret_arr->elems, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
33149 void __attribute__((export_name("TS_RevokeAndACK_set_per_commitment_secret"))) TS_RevokeAndACK_set_per_commitment_secret(uint64_t this_ptr, int8_tArray val) {
33150 LDKRevokeAndACK this_ptr_conv;
33151 this_ptr_conv.inner = untag_ptr(this_ptr);
33152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33154 this_ptr_conv.is_owned = false;
33155 LDKThirtyTwoBytes val_ref;
33156 CHECK(val->arr_len == 32);
33157 memcpy(val_ref.data, val->elems, 32); FREE(val);
33158 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
33161 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_next_per_commitment_point"))) TS_RevokeAndACK_get_next_per_commitment_point(uint64_t this_ptr) {
33162 LDKRevokeAndACK this_ptr_conv;
33163 this_ptr_conv.inner = untag_ptr(this_ptr);
33164 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33166 this_ptr_conv.is_owned = false;
33167 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33168 memcpy(ret_arr->elems, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
33172 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) {
33173 LDKRevokeAndACK this_ptr_conv;
33174 this_ptr_conv.inner = untag_ptr(this_ptr);
33175 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33177 this_ptr_conv.is_owned = false;
33178 LDKPublicKey val_ref;
33179 CHECK(val->arr_len == 33);
33180 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33181 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
33184 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) {
33185 LDKThirtyTwoBytes channel_id_arg_ref;
33186 CHECK(channel_id_arg->arr_len == 32);
33187 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33188 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
33189 CHECK(per_commitment_secret_arg->arr_len == 32);
33190 memcpy(per_commitment_secret_arg_ref.data, per_commitment_secret_arg->elems, 32); FREE(per_commitment_secret_arg);
33191 LDKPublicKey next_per_commitment_point_arg_ref;
33192 CHECK(next_per_commitment_point_arg->arr_len == 33);
33193 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
33194 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
33195 uint64_t ret_ref = 0;
33196 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33197 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33201 static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
33202 LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
33203 uint64_t ret_ref = 0;
33204 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33205 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33208 int64_t __attribute__((export_name("TS_RevokeAndACK_clone_ptr"))) TS_RevokeAndACK_clone_ptr(uint64_t arg) {
33209 LDKRevokeAndACK arg_conv;
33210 arg_conv.inner = untag_ptr(arg);
33211 arg_conv.is_owned = ptr_is_owned(arg);
33212 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33213 arg_conv.is_owned = false;
33214 int64_t ret_conv = RevokeAndACK_clone_ptr(&arg_conv);
33218 uint64_t __attribute__((export_name("TS_RevokeAndACK_clone"))) TS_RevokeAndACK_clone(uint64_t orig) {
33219 LDKRevokeAndACK orig_conv;
33220 orig_conv.inner = untag_ptr(orig);
33221 orig_conv.is_owned = ptr_is_owned(orig);
33222 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33223 orig_conv.is_owned = false;
33224 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
33225 uint64_t ret_ref = 0;
33226 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33227 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33231 jboolean __attribute__((export_name("TS_RevokeAndACK_eq"))) TS_RevokeAndACK_eq(uint64_t a, uint64_t b) {
33232 LDKRevokeAndACK a_conv;
33233 a_conv.inner = untag_ptr(a);
33234 a_conv.is_owned = ptr_is_owned(a);
33235 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33236 a_conv.is_owned = false;
33237 LDKRevokeAndACK b_conv;
33238 b_conv.inner = untag_ptr(b);
33239 b_conv.is_owned = ptr_is_owned(b);
33240 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33241 b_conv.is_owned = false;
33242 jboolean ret_conv = RevokeAndACK_eq(&a_conv, &b_conv);
33246 void __attribute__((export_name("TS_UpdateFee_free"))) TS_UpdateFee_free(uint64_t this_obj) {
33247 LDKUpdateFee this_obj_conv;
33248 this_obj_conv.inner = untag_ptr(this_obj);
33249 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33251 UpdateFee_free(this_obj_conv);
33254 int8_tArray __attribute__((export_name("TS_UpdateFee_get_channel_id"))) TS_UpdateFee_get_channel_id(uint64_t this_ptr) {
33255 LDKUpdateFee this_ptr_conv;
33256 this_ptr_conv.inner = untag_ptr(this_ptr);
33257 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33259 this_ptr_conv.is_owned = false;
33260 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33261 memcpy(ret_arr->elems, *UpdateFee_get_channel_id(&this_ptr_conv), 32);
33265 void __attribute__((export_name("TS_UpdateFee_set_channel_id"))) TS_UpdateFee_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33266 LDKUpdateFee this_ptr_conv;
33267 this_ptr_conv.inner = untag_ptr(this_ptr);
33268 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33270 this_ptr_conv.is_owned = false;
33271 LDKThirtyTwoBytes val_ref;
33272 CHECK(val->arr_len == 32);
33273 memcpy(val_ref.data, val->elems, 32); FREE(val);
33274 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
33277 int32_t __attribute__((export_name("TS_UpdateFee_get_feerate_per_kw"))) TS_UpdateFee_get_feerate_per_kw(uint64_t this_ptr) {
33278 LDKUpdateFee this_ptr_conv;
33279 this_ptr_conv.inner = untag_ptr(this_ptr);
33280 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33282 this_ptr_conv.is_owned = false;
33283 int32_t ret_conv = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
33287 void __attribute__((export_name("TS_UpdateFee_set_feerate_per_kw"))) TS_UpdateFee_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
33288 LDKUpdateFee this_ptr_conv;
33289 this_ptr_conv.inner = untag_ptr(this_ptr);
33290 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33292 this_ptr_conv.is_owned = false;
33293 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
33296 uint64_t __attribute__((export_name("TS_UpdateFee_new"))) TS_UpdateFee_new(int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
33297 LDKThirtyTwoBytes channel_id_arg_ref;
33298 CHECK(channel_id_arg->arr_len == 32);
33299 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33300 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
33301 uint64_t ret_ref = 0;
33302 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33303 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33307 static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
33308 LDKUpdateFee ret_var = UpdateFee_clone(arg);
33309 uint64_t ret_ref = 0;
33310 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33311 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33314 int64_t __attribute__((export_name("TS_UpdateFee_clone_ptr"))) TS_UpdateFee_clone_ptr(uint64_t arg) {
33315 LDKUpdateFee arg_conv;
33316 arg_conv.inner = untag_ptr(arg);
33317 arg_conv.is_owned = ptr_is_owned(arg);
33318 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33319 arg_conv.is_owned = false;
33320 int64_t ret_conv = UpdateFee_clone_ptr(&arg_conv);
33324 uint64_t __attribute__((export_name("TS_UpdateFee_clone"))) TS_UpdateFee_clone(uint64_t orig) {
33325 LDKUpdateFee orig_conv;
33326 orig_conv.inner = untag_ptr(orig);
33327 orig_conv.is_owned = ptr_is_owned(orig);
33328 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33329 orig_conv.is_owned = false;
33330 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
33331 uint64_t ret_ref = 0;
33332 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33333 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33337 jboolean __attribute__((export_name("TS_UpdateFee_eq"))) TS_UpdateFee_eq(uint64_t a, uint64_t b) {
33338 LDKUpdateFee a_conv;
33339 a_conv.inner = untag_ptr(a);
33340 a_conv.is_owned = ptr_is_owned(a);
33341 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33342 a_conv.is_owned = false;
33343 LDKUpdateFee b_conv;
33344 b_conv.inner = untag_ptr(b);
33345 b_conv.is_owned = ptr_is_owned(b);
33346 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33347 b_conv.is_owned = false;
33348 jboolean ret_conv = UpdateFee_eq(&a_conv, &b_conv);
33352 void __attribute__((export_name("TS_DataLossProtect_free"))) TS_DataLossProtect_free(uint64_t this_obj) {
33353 LDKDataLossProtect this_obj_conv;
33354 this_obj_conv.inner = untag_ptr(this_obj);
33355 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33356 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33357 DataLossProtect_free(this_obj_conv);
33360 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) {
33361 LDKDataLossProtect this_ptr_conv;
33362 this_ptr_conv.inner = untag_ptr(this_ptr);
33363 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33365 this_ptr_conv.is_owned = false;
33366 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33367 memcpy(ret_arr->elems, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
33371 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) {
33372 LDKDataLossProtect this_ptr_conv;
33373 this_ptr_conv.inner = untag_ptr(this_ptr);
33374 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33376 this_ptr_conv.is_owned = false;
33377 LDKThirtyTwoBytes val_ref;
33378 CHECK(val->arr_len == 32);
33379 memcpy(val_ref.data, val->elems, 32); FREE(val);
33380 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
33383 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) {
33384 LDKDataLossProtect this_ptr_conv;
33385 this_ptr_conv.inner = untag_ptr(this_ptr);
33386 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33388 this_ptr_conv.is_owned = false;
33389 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33390 memcpy(ret_arr->elems, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
33394 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) {
33395 LDKDataLossProtect this_ptr_conv;
33396 this_ptr_conv.inner = untag_ptr(this_ptr);
33397 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33399 this_ptr_conv.is_owned = false;
33400 LDKPublicKey val_ref;
33401 CHECK(val->arr_len == 33);
33402 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33403 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
33406 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) {
33407 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
33408 CHECK(your_last_per_commitment_secret_arg->arr_len == 32);
33409 memcpy(your_last_per_commitment_secret_arg_ref.data, your_last_per_commitment_secret_arg->elems, 32); FREE(your_last_per_commitment_secret_arg);
33410 LDKPublicKey my_current_per_commitment_point_arg_ref;
33411 CHECK(my_current_per_commitment_point_arg->arr_len == 33);
33412 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);
33413 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
33414 uint64_t ret_ref = 0;
33415 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33416 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33420 static inline uint64_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
33421 LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
33422 uint64_t ret_ref = 0;
33423 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33424 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33427 int64_t __attribute__((export_name("TS_DataLossProtect_clone_ptr"))) TS_DataLossProtect_clone_ptr(uint64_t arg) {
33428 LDKDataLossProtect arg_conv;
33429 arg_conv.inner = untag_ptr(arg);
33430 arg_conv.is_owned = ptr_is_owned(arg);
33431 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33432 arg_conv.is_owned = false;
33433 int64_t ret_conv = DataLossProtect_clone_ptr(&arg_conv);
33437 uint64_t __attribute__((export_name("TS_DataLossProtect_clone"))) TS_DataLossProtect_clone(uint64_t orig) {
33438 LDKDataLossProtect orig_conv;
33439 orig_conv.inner = untag_ptr(orig);
33440 orig_conv.is_owned = ptr_is_owned(orig);
33441 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33442 orig_conv.is_owned = false;
33443 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
33444 uint64_t ret_ref = 0;
33445 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33446 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33450 jboolean __attribute__((export_name("TS_DataLossProtect_eq"))) TS_DataLossProtect_eq(uint64_t a, uint64_t b) {
33451 LDKDataLossProtect a_conv;
33452 a_conv.inner = untag_ptr(a);
33453 a_conv.is_owned = ptr_is_owned(a);
33454 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33455 a_conv.is_owned = false;
33456 LDKDataLossProtect b_conv;
33457 b_conv.inner = untag_ptr(b);
33458 b_conv.is_owned = ptr_is_owned(b);
33459 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33460 b_conv.is_owned = false;
33461 jboolean ret_conv = DataLossProtect_eq(&a_conv, &b_conv);
33465 void __attribute__((export_name("TS_ChannelReestablish_free"))) TS_ChannelReestablish_free(uint64_t this_obj) {
33466 LDKChannelReestablish this_obj_conv;
33467 this_obj_conv.inner = untag_ptr(this_obj);
33468 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33469 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33470 ChannelReestablish_free(this_obj_conv);
33473 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_channel_id"))) TS_ChannelReestablish_get_channel_id(uint64_t this_ptr) {
33474 LDKChannelReestablish this_ptr_conv;
33475 this_ptr_conv.inner = untag_ptr(this_ptr);
33476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33478 this_ptr_conv.is_owned = false;
33479 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33480 memcpy(ret_arr->elems, *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
33484 void __attribute__((export_name("TS_ChannelReestablish_set_channel_id"))) TS_ChannelReestablish_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33485 LDKChannelReestablish this_ptr_conv;
33486 this_ptr_conv.inner = untag_ptr(this_ptr);
33487 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33488 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33489 this_ptr_conv.is_owned = false;
33490 LDKThirtyTwoBytes val_ref;
33491 CHECK(val->arr_len == 32);
33492 memcpy(val_ref.data, val->elems, 32); FREE(val);
33493 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
33496 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_local_commitment_number"))) TS_ChannelReestablish_get_next_local_commitment_number(uint64_t this_ptr) {
33497 LDKChannelReestablish this_ptr_conv;
33498 this_ptr_conv.inner = untag_ptr(this_ptr);
33499 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33501 this_ptr_conv.is_owned = false;
33502 int64_t ret_conv = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
33506 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) {
33507 LDKChannelReestablish this_ptr_conv;
33508 this_ptr_conv.inner = untag_ptr(this_ptr);
33509 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33510 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33511 this_ptr_conv.is_owned = false;
33512 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
33515 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_remote_commitment_number"))) TS_ChannelReestablish_get_next_remote_commitment_number(uint64_t this_ptr) {
33516 LDKChannelReestablish this_ptr_conv;
33517 this_ptr_conv.inner = untag_ptr(this_ptr);
33518 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33520 this_ptr_conv.is_owned = false;
33521 int64_t ret_conv = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
33525 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) {
33526 LDKChannelReestablish this_ptr_conv;
33527 this_ptr_conv.inner = untag_ptr(this_ptr);
33528 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33529 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33530 this_ptr_conv.is_owned = false;
33531 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
33534 static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
33535 LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
33536 uint64_t ret_ref = 0;
33537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33541 int64_t __attribute__((export_name("TS_ChannelReestablish_clone_ptr"))) TS_ChannelReestablish_clone_ptr(uint64_t arg) {
33542 LDKChannelReestablish arg_conv;
33543 arg_conv.inner = untag_ptr(arg);
33544 arg_conv.is_owned = ptr_is_owned(arg);
33545 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33546 arg_conv.is_owned = false;
33547 int64_t ret_conv = ChannelReestablish_clone_ptr(&arg_conv);
33551 uint64_t __attribute__((export_name("TS_ChannelReestablish_clone"))) TS_ChannelReestablish_clone(uint64_t orig) {
33552 LDKChannelReestablish orig_conv;
33553 orig_conv.inner = untag_ptr(orig);
33554 orig_conv.is_owned = ptr_is_owned(orig);
33555 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33556 orig_conv.is_owned = false;
33557 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
33558 uint64_t ret_ref = 0;
33559 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33560 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33564 jboolean __attribute__((export_name("TS_ChannelReestablish_eq"))) TS_ChannelReestablish_eq(uint64_t a, uint64_t b) {
33565 LDKChannelReestablish a_conv;
33566 a_conv.inner = untag_ptr(a);
33567 a_conv.is_owned = ptr_is_owned(a);
33568 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33569 a_conv.is_owned = false;
33570 LDKChannelReestablish b_conv;
33571 b_conv.inner = untag_ptr(b);
33572 b_conv.is_owned = ptr_is_owned(b);
33573 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33574 b_conv.is_owned = false;
33575 jboolean ret_conv = ChannelReestablish_eq(&a_conv, &b_conv);
33579 void __attribute__((export_name("TS_AnnouncementSignatures_free"))) TS_AnnouncementSignatures_free(uint64_t this_obj) {
33580 LDKAnnouncementSignatures this_obj_conv;
33581 this_obj_conv.inner = untag_ptr(this_obj);
33582 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33584 AnnouncementSignatures_free(this_obj_conv);
33587 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_channel_id"))) TS_AnnouncementSignatures_get_channel_id(uint64_t this_ptr) {
33588 LDKAnnouncementSignatures this_ptr_conv;
33589 this_ptr_conv.inner = untag_ptr(this_ptr);
33590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33592 this_ptr_conv.is_owned = false;
33593 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33594 memcpy(ret_arr->elems, *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
33598 void __attribute__((export_name("TS_AnnouncementSignatures_set_channel_id"))) TS_AnnouncementSignatures_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33599 LDKAnnouncementSignatures this_ptr_conv;
33600 this_ptr_conv.inner = untag_ptr(this_ptr);
33601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33603 this_ptr_conv.is_owned = false;
33604 LDKThirtyTwoBytes val_ref;
33605 CHECK(val->arr_len == 32);
33606 memcpy(val_ref.data, val->elems, 32); FREE(val);
33607 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
33610 int64_t __attribute__((export_name("TS_AnnouncementSignatures_get_short_channel_id"))) TS_AnnouncementSignatures_get_short_channel_id(uint64_t this_ptr) {
33611 LDKAnnouncementSignatures this_ptr_conv;
33612 this_ptr_conv.inner = untag_ptr(this_ptr);
33613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33615 this_ptr_conv.is_owned = false;
33616 int64_t ret_conv = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
33620 void __attribute__((export_name("TS_AnnouncementSignatures_set_short_channel_id"))) TS_AnnouncementSignatures_set_short_channel_id(uint64_t this_ptr, int64_t val) {
33621 LDKAnnouncementSignatures this_ptr_conv;
33622 this_ptr_conv.inner = untag_ptr(this_ptr);
33623 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33624 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33625 this_ptr_conv.is_owned = false;
33626 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
33629 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_node_signature"))) TS_AnnouncementSignatures_get_node_signature(uint64_t this_ptr) {
33630 LDKAnnouncementSignatures this_ptr_conv;
33631 this_ptr_conv.inner = untag_ptr(this_ptr);
33632 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33633 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33634 this_ptr_conv.is_owned = false;
33635 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33636 memcpy(ret_arr->elems, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
33640 void __attribute__((export_name("TS_AnnouncementSignatures_set_node_signature"))) TS_AnnouncementSignatures_set_node_signature(uint64_t this_ptr, int8_tArray val) {
33641 LDKAnnouncementSignatures this_ptr_conv;
33642 this_ptr_conv.inner = untag_ptr(this_ptr);
33643 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33645 this_ptr_conv.is_owned = false;
33646 LDKSignature val_ref;
33647 CHECK(val->arr_len == 64);
33648 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33649 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
33652 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_bitcoin_signature"))) TS_AnnouncementSignatures_get_bitcoin_signature(uint64_t this_ptr) {
33653 LDKAnnouncementSignatures this_ptr_conv;
33654 this_ptr_conv.inner = untag_ptr(this_ptr);
33655 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33656 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33657 this_ptr_conv.is_owned = false;
33658 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
33659 memcpy(ret_arr->elems, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
33663 void __attribute__((export_name("TS_AnnouncementSignatures_set_bitcoin_signature"))) TS_AnnouncementSignatures_set_bitcoin_signature(uint64_t this_ptr, int8_tArray val) {
33664 LDKAnnouncementSignatures this_ptr_conv;
33665 this_ptr_conv.inner = untag_ptr(this_ptr);
33666 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33668 this_ptr_conv.is_owned = false;
33669 LDKSignature val_ref;
33670 CHECK(val->arr_len == 64);
33671 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
33672 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
33675 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) {
33676 LDKThirtyTwoBytes channel_id_arg_ref;
33677 CHECK(channel_id_arg->arr_len == 32);
33678 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
33679 LDKSignature node_signature_arg_ref;
33680 CHECK(node_signature_arg->arr_len == 64);
33681 memcpy(node_signature_arg_ref.compact_form, node_signature_arg->elems, 64); FREE(node_signature_arg);
33682 LDKSignature bitcoin_signature_arg_ref;
33683 CHECK(bitcoin_signature_arg->arr_len == 64);
33684 memcpy(bitcoin_signature_arg_ref.compact_form, bitcoin_signature_arg->elems, 64); FREE(bitcoin_signature_arg);
33685 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
33686 uint64_t ret_ref = 0;
33687 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33688 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33692 static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
33693 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
33694 uint64_t ret_ref = 0;
33695 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33696 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33699 int64_t __attribute__((export_name("TS_AnnouncementSignatures_clone_ptr"))) TS_AnnouncementSignatures_clone_ptr(uint64_t arg) {
33700 LDKAnnouncementSignatures arg_conv;
33701 arg_conv.inner = untag_ptr(arg);
33702 arg_conv.is_owned = ptr_is_owned(arg);
33703 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33704 arg_conv.is_owned = false;
33705 int64_t ret_conv = AnnouncementSignatures_clone_ptr(&arg_conv);
33709 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_clone"))) TS_AnnouncementSignatures_clone(uint64_t orig) {
33710 LDKAnnouncementSignatures orig_conv;
33711 orig_conv.inner = untag_ptr(orig);
33712 orig_conv.is_owned = ptr_is_owned(orig);
33713 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33714 orig_conv.is_owned = false;
33715 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
33716 uint64_t ret_ref = 0;
33717 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33718 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33722 jboolean __attribute__((export_name("TS_AnnouncementSignatures_eq"))) TS_AnnouncementSignatures_eq(uint64_t a, uint64_t b) {
33723 LDKAnnouncementSignatures a_conv;
33724 a_conv.inner = untag_ptr(a);
33725 a_conv.is_owned = ptr_is_owned(a);
33726 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33727 a_conv.is_owned = false;
33728 LDKAnnouncementSignatures b_conv;
33729 b_conv.inner = untag_ptr(b);
33730 b_conv.is_owned = ptr_is_owned(b);
33731 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33732 b_conv.is_owned = false;
33733 jboolean ret_conv = AnnouncementSignatures_eq(&a_conv, &b_conv);
33737 void __attribute__((export_name("TS_NetAddress_free"))) TS_NetAddress_free(uint64_t this_ptr) {
33738 if (!ptr_is_owned(this_ptr)) return;
33739 void* this_ptr_ptr = untag_ptr(this_ptr);
33740 CHECK_ACCESS(this_ptr_ptr);
33741 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(this_ptr_ptr);
33742 FREE(untag_ptr(this_ptr));
33743 NetAddress_free(this_ptr_conv);
33746 static inline uint64_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
33747 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33748 *ret_copy = NetAddress_clone(arg);
33749 uint64_t ret_ref = tag_ptr(ret_copy, true);
33752 int64_t __attribute__((export_name("TS_NetAddress_clone_ptr"))) TS_NetAddress_clone_ptr(uint64_t arg) {
33753 LDKNetAddress* arg_conv = (LDKNetAddress*)untag_ptr(arg);
33754 int64_t ret_conv = NetAddress_clone_ptr(arg_conv);
33758 uint64_t __attribute__((export_name("TS_NetAddress_clone"))) TS_NetAddress_clone(uint64_t orig) {
33759 LDKNetAddress* orig_conv = (LDKNetAddress*)untag_ptr(orig);
33760 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33761 *ret_copy = NetAddress_clone(orig_conv);
33762 uint64_t ret_ref = tag_ptr(ret_copy, true);
33766 uint64_t __attribute__((export_name("TS_NetAddress_ipv4"))) TS_NetAddress_ipv4(int8_tArray addr, int16_t port) {
33767 LDKFourBytes addr_ref;
33768 CHECK(addr->arr_len == 4);
33769 memcpy(addr_ref.data, addr->elems, 4); FREE(addr);
33770 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33771 *ret_copy = NetAddress_ipv4(addr_ref, port);
33772 uint64_t ret_ref = tag_ptr(ret_copy, true);
33776 uint64_t __attribute__((export_name("TS_NetAddress_ipv6"))) TS_NetAddress_ipv6(int8_tArray addr, int16_t port) {
33777 LDKSixteenBytes addr_ref;
33778 CHECK(addr->arr_len == 16);
33779 memcpy(addr_ref.data, addr->elems, 16); FREE(addr);
33780 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33781 *ret_copy = NetAddress_ipv6(addr_ref, port);
33782 uint64_t ret_ref = tag_ptr(ret_copy, true);
33786 uint64_t __attribute__((export_name("TS_NetAddress_onion_v2"))) TS_NetAddress_onion_v2(int8_tArray a) {
33787 LDKTwelveBytes a_ref;
33788 CHECK(a->arr_len == 12);
33789 memcpy(a_ref.data, a->elems, 12); FREE(a);
33790 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33791 *ret_copy = NetAddress_onion_v2(a_ref);
33792 uint64_t ret_ref = tag_ptr(ret_copy, true);
33796 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) {
33797 LDKThirtyTwoBytes ed25519_pubkey_ref;
33798 CHECK(ed25519_pubkey->arr_len == 32);
33799 memcpy(ed25519_pubkey_ref.data, ed25519_pubkey->elems, 32); FREE(ed25519_pubkey);
33800 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33801 *ret_copy = NetAddress_onion_v3(ed25519_pubkey_ref, checksum, version, port);
33802 uint64_t ret_ref = tag_ptr(ret_copy, true);
33806 uint64_t __attribute__((export_name("TS_NetAddress_hostname"))) TS_NetAddress_hostname(uint64_t hostname, int16_t port) {
33807 LDKHostname hostname_conv;
33808 hostname_conv.inner = untag_ptr(hostname);
33809 hostname_conv.is_owned = ptr_is_owned(hostname);
33810 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_conv);
33811 hostname_conv = Hostname_clone(&hostname_conv);
33812 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
33813 *ret_copy = NetAddress_hostname(hostname_conv, port);
33814 uint64_t ret_ref = tag_ptr(ret_copy, true);
33818 jboolean __attribute__((export_name("TS_NetAddress_eq"))) TS_NetAddress_eq(uint64_t a, uint64_t b) {
33819 LDKNetAddress* a_conv = (LDKNetAddress*)untag_ptr(a);
33820 LDKNetAddress* b_conv = (LDKNetAddress*)untag_ptr(b);
33821 jboolean ret_conv = NetAddress_eq(a_conv, b_conv);
33825 int8_tArray __attribute__((export_name("TS_NetAddress_write"))) TS_NetAddress_write(uint64_t obj) {
33826 LDKNetAddress* obj_conv = (LDKNetAddress*)untag_ptr(obj);
33827 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
33828 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33829 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33830 CVec_u8Z_free(ret_var);
33834 uint64_t __attribute__((export_name("TS_NetAddress_read"))) TS_NetAddress_read(int8_tArray ser) {
33835 LDKu8slice ser_ref;
33836 ser_ref.datalen = ser->arr_len;
33837 ser_ref.data = ser->elems;
33838 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
33839 *ret_conv = NetAddress_read(ser_ref);
33841 return tag_ptr(ret_conv, true);
33844 void __attribute__((export_name("TS_UnsignedGossipMessage_free"))) TS_UnsignedGossipMessage_free(uint64_t this_ptr) {
33845 if (!ptr_is_owned(this_ptr)) return;
33846 void* this_ptr_ptr = untag_ptr(this_ptr);
33847 CHECK_ACCESS(this_ptr_ptr);
33848 LDKUnsignedGossipMessage this_ptr_conv = *(LDKUnsignedGossipMessage*)(this_ptr_ptr);
33849 FREE(untag_ptr(this_ptr));
33850 UnsignedGossipMessage_free(this_ptr_conv);
33853 static inline uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg) {
33854 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33855 *ret_copy = UnsignedGossipMessage_clone(arg);
33856 uint64_t ret_ref = tag_ptr(ret_copy, true);
33859 int64_t __attribute__((export_name("TS_UnsignedGossipMessage_clone_ptr"))) TS_UnsignedGossipMessage_clone_ptr(uint64_t arg) {
33860 LDKUnsignedGossipMessage* arg_conv = (LDKUnsignedGossipMessage*)untag_ptr(arg);
33861 int64_t ret_conv = UnsignedGossipMessage_clone_ptr(arg_conv);
33865 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_clone"))) TS_UnsignedGossipMessage_clone(uint64_t orig) {
33866 LDKUnsignedGossipMessage* orig_conv = (LDKUnsignedGossipMessage*)untag_ptr(orig);
33867 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33868 *ret_copy = UnsignedGossipMessage_clone(orig_conv);
33869 uint64_t ret_ref = tag_ptr(ret_copy, true);
33873 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_channel_announcement"))) TS_UnsignedGossipMessage_channel_announcement(uint64_t a) {
33874 LDKUnsignedChannelAnnouncement a_conv;
33875 a_conv.inner = untag_ptr(a);
33876 a_conv.is_owned = ptr_is_owned(a);
33877 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33878 a_conv = UnsignedChannelAnnouncement_clone(&a_conv);
33879 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33880 *ret_copy = UnsignedGossipMessage_channel_announcement(a_conv);
33881 uint64_t ret_ref = tag_ptr(ret_copy, true);
33885 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_channel_update"))) TS_UnsignedGossipMessage_channel_update(uint64_t a) {
33886 LDKUnsignedChannelUpdate a_conv;
33887 a_conv.inner = untag_ptr(a);
33888 a_conv.is_owned = ptr_is_owned(a);
33889 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33890 a_conv = UnsignedChannelUpdate_clone(&a_conv);
33891 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33892 *ret_copy = UnsignedGossipMessage_channel_update(a_conv);
33893 uint64_t ret_ref = tag_ptr(ret_copy, true);
33897 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_node_announcement"))) TS_UnsignedGossipMessage_node_announcement(uint64_t a) {
33898 LDKUnsignedNodeAnnouncement a_conv;
33899 a_conv.inner = untag_ptr(a);
33900 a_conv.is_owned = ptr_is_owned(a);
33901 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33902 a_conv = UnsignedNodeAnnouncement_clone(&a_conv);
33903 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
33904 *ret_copy = UnsignedGossipMessage_node_announcement(a_conv);
33905 uint64_t ret_ref = tag_ptr(ret_copy, true);
33909 int8_tArray __attribute__((export_name("TS_UnsignedGossipMessage_write"))) TS_UnsignedGossipMessage_write(uint64_t obj) {
33910 LDKUnsignedGossipMessage* obj_conv = (LDKUnsignedGossipMessage*)untag_ptr(obj);
33911 LDKCVec_u8Z ret_var = UnsignedGossipMessage_write(obj_conv);
33912 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33913 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33914 CVec_u8Z_free(ret_var);
33918 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_free"))) TS_UnsignedNodeAnnouncement_free(uint64_t this_obj) {
33919 LDKUnsignedNodeAnnouncement this_obj_conv;
33920 this_obj_conv.inner = untag_ptr(this_obj);
33921 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33922 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33923 UnsignedNodeAnnouncement_free(this_obj_conv);
33926 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_features"))) TS_UnsignedNodeAnnouncement_get_features(uint64_t this_ptr) {
33927 LDKUnsignedNodeAnnouncement this_ptr_conv;
33928 this_ptr_conv.inner = untag_ptr(this_ptr);
33929 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33930 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33931 this_ptr_conv.is_owned = false;
33932 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
33933 uint64_t ret_ref = 0;
33934 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33935 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33939 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_features"))) TS_UnsignedNodeAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
33940 LDKUnsignedNodeAnnouncement this_ptr_conv;
33941 this_ptr_conv.inner = untag_ptr(this_ptr);
33942 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33943 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33944 this_ptr_conv.is_owned = false;
33945 LDKNodeFeatures val_conv;
33946 val_conv.inner = untag_ptr(val);
33947 val_conv.is_owned = ptr_is_owned(val);
33948 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33949 val_conv = NodeFeatures_clone(&val_conv);
33950 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
33953 int32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_timestamp"))) TS_UnsignedNodeAnnouncement_get_timestamp(uint64_t this_ptr) {
33954 LDKUnsignedNodeAnnouncement this_ptr_conv;
33955 this_ptr_conv.inner = untag_ptr(this_ptr);
33956 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33958 this_ptr_conv.is_owned = false;
33959 int32_t ret_conv = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
33963 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_timestamp"))) TS_UnsignedNodeAnnouncement_set_timestamp(uint64_t this_ptr, int32_t val) {
33964 LDKUnsignedNodeAnnouncement this_ptr_conv;
33965 this_ptr_conv.inner = untag_ptr(this_ptr);
33966 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33968 this_ptr_conv.is_owned = false;
33969 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
33972 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_node_id"))) TS_UnsignedNodeAnnouncement_get_node_id(uint64_t this_ptr) {
33973 LDKUnsignedNodeAnnouncement this_ptr_conv;
33974 this_ptr_conv.inner = untag_ptr(this_ptr);
33975 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33977 this_ptr_conv.is_owned = false;
33978 LDKNodeId ret_var = UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv);
33979 uint64_t ret_ref = 0;
33980 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33981 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33985 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_node_id"))) TS_UnsignedNodeAnnouncement_set_node_id(uint64_t this_ptr, uint64_t val) {
33986 LDKUnsignedNodeAnnouncement this_ptr_conv;
33987 this_ptr_conv.inner = untag_ptr(this_ptr);
33988 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33990 this_ptr_conv.is_owned = false;
33991 LDKNodeId val_conv;
33992 val_conv.inner = untag_ptr(val);
33993 val_conv.is_owned = ptr_is_owned(val);
33994 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33995 val_conv = NodeId_clone(&val_conv);
33996 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_conv);
33999 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_rgb"))) TS_UnsignedNodeAnnouncement_get_rgb(uint64_t this_ptr) {
34000 LDKUnsignedNodeAnnouncement this_ptr_conv;
34001 this_ptr_conv.inner = untag_ptr(this_ptr);
34002 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34004 this_ptr_conv.is_owned = false;
34005 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
34006 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
34010 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_rgb"))) TS_UnsignedNodeAnnouncement_set_rgb(uint64_t this_ptr, int8_tArray val) {
34011 LDKUnsignedNodeAnnouncement this_ptr_conv;
34012 this_ptr_conv.inner = untag_ptr(this_ptr);
34013 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34014 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34015 this_ptr_conv.is_owned = false;
34016 LDKThreeBytes val_ref;
34017 CHECK(val->arr_len == 3);
34018 memcpy(val_ref.data, val->elems, 3); FREE(val);
34019 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
34022 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_alias"))) TS_UnsignedNodeAnnouncement_get_alias(uint64_t this_ptr) {
34023 LDKUnsignedNodeAnnouncement this_ptr_conv;
34024 this_ptr_conv.inner = untag_ptr(this_ptr);
34025 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34026 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34027 this_ptr_conv.is_owned = false;
34028 LDKNodeAlias ret_var = UnsignedNodeAnnouncement_get_alias(&this_ptr_conv);
34029 uint64_t ret_ref = 0;
34030 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34031 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34035 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_alias"))) TS_UnsignedNodeAnnouncement_set_alias(uint64_t this_ptr, uint64_t val) {
34036 LDKUnsignedNodeAnnouncement this_ptr_conv;
34037 this_ptr_conv.inner = untag_ptr(this_ptr);
34038 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34040 this_ptr_conv.is_owned = false;
34041 LDKNodeAlias val_conv;
34042 val_conv.inner = untag_ptr(val);
34043 val_conv.is_owned = ptr_is_owned(val);
34044 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34045 val_conv = NodeAlias_clone(&val_conv);
34046 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_conv);
34049 uint64_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_addresses"))) TS_UnsignedNodeAnnouncement_get_addresses(uint64_t this_ptr) {
34050 LDKUnsignedNodeAnnouncement this_ptr_conv;
34051 this_ptr_conv.inner = untag_ptr(this_ptr);
34052 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34053 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34054 this_ptr_conv.is_owned = false;
34055 LDKCVec_NetAddressZ ret_var = UnsignedNodeAnnouncement_get_addresses(&this_ptr_conv);
34056 uint64_tArray ret_arr = NULL;
34057 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34058 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34059 for (size_t m = 0; m < ret_var.datalen; m++) {
34060 LDKNetAddress *ret_conv_12_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
34061 *ret_conv_12_copy = ret_var.data[m];
34062 uint64_t ret_conv_12_ref = tag_ptr(ret_conv_12_copy, true);
34063 ret_arr_ptr[m] = ret_conv_12_ref;
34066 FREE(ret_var.data);
34070 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_addresses"))) TS_UnsignedNodeAnnouncement_set_addresses(uint64_t this_ptr, uint64_tArray val) {
34071 LDKUnsignedNodeAnnouncement this_ptr_conv;
34072 this_ptr_conv.inner = untag_ptr(this_ptr);
34073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34075 this_ptr_conv.is_owned = false;
34076 LDKCVec_NetAddressZ val_constr;
34077 val_constr.datalen = val->arr_len;
34078 if (val_constr.datalen > 0)
34079 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
34081 val_constr.data = NULL;
34082 uint64_t* val_vals = val->elems;
34083 for (size_t m = 0; m < val_constr.datalen; m++) {
34084 uint64_t val_conv_12 = val_vals[m];
34085 void* val_conv_12_ptr = untag_ptr(val_conv_12);
34086 CHECK_ACCESS(val_conv_12_ptr);
34087 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(val_conv_12_ptr);
34088 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)untag_ptr(val_conv_12));
34089 val_constr.data[m] = val_conv_12_conv;
34092 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
34095 static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
34096 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
34097 uint64_t ret_ref = 0;
34098 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34099 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34102 int64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone_ptr"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint64_t arg) {
34103 LDKUnsignedNodeAnnouncement arg_conv;
34104 arg_conv.inner = untag_ptr(arg);
34105 arg_conv.is_owned = ptr_is_owned(arg);
34106 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34107 arg_conv.is_owned = false;
34108 int64_t ret_conv = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
34112 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone"))) TS_UnsignedNodeAnnouncement_clone(uint64_t orig) {
34113 LDKUnsignedNodeAnnouncement orig_conv;
34114 orig_conv.inner = untag_ptr(orig);
34115 orig_conv.is_owned = ptr_is_owned(orig);
34116 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34117 orig_conv.is_owned = false;
34118 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
34119 uint64_t ret_ref = 0;
34120 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34121 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34125 jboolean __attribute__((export_name("TS_UnsignedNodeAnnouncement_eq"))) TS_UnsignedNodeAnnouncement_eq(uint64_t a, uint64_t b) {
34126 LDKUnsignedNodeAnnouncement a_conv;
34127 a_conv.inner = untag_ptr(a);
34128 a_conv.is_owned = ptr_is_owned(a);
34129 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34130 a_conv.is_owned = false;
34131 LDKUnsignedNodeAnnouncement b_conv;
34132 b_conv.inner = untag_ptr(b);
34133 b_conv.is_owned = ptr_is_owned(b);
34134 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34135 b_conv.is_owned = false;
34136 jboolean ret_conv = UnsignedNodeAnnouncement_eq(&a_conv, &b_conv);
34140 void __attribute__((export_name("TS_NodeAnnouncement_free"))) TS_NodeAnnouncement_free(uint64_t this_obj) {
34141 LDKNodeAnnouncement this_obj_conv;
34142 this_obj_conv.inner = untag_ptr(this_obj);
34143 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34144 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34145 NodeAnnouncement_free(this_obj_conv);
34148 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_get_signature"))) TS_NodeAnnouncement_get_signature(uint64_t this_ptr) {
34149 LDKNodeAnnouncement this_ptr_conv;
34150 this_ptr_conv.inner = untag_ptr(this_ptr);
34151 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34152 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34153 this_ptr_conv.is_owned = false;
34154 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34155 memcpy(ret_arr->elems, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
34159 void __attribute__((export_name("TS_NodeAnnouncement_set_signature"))) TS_NodeAnnouncement_set_signature(uint64_t this_ptr, int8_tArray val) {
34160 LDKNodeAnnouncement this_ptr_conv;
34161 this_ptr_conv.inner = untag_ptr(this_ptr);
34162 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34164 this_ptr_conv.is_owned = false;
34165 LDKSignature val_ref;
34166 CHECK(val->arr_len == 64);
34167 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34168 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
34171 uint64_t __attribute__((export_name("TS_NodeAnnouncement_get_contents"))) TS_NodeAnnouncement_get_contents(uint64_t this_ptr) {
34172 LDKNodeAnnouncement this_ptr_conv;
34173 this_ptr_conv.inner = untag_ptr(this_ptr);
34174 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34175 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34176 this_ptr_conv.is_owned = false;
34177 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
34178 uint64_t ret_ref = 0;
34179 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34180 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34184 void __attribute__((export_name("TS_NodeAnnouncement_set_contents"))) TS_NodeAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
34185 LDKNodeAnnouncement this_ptr_conv;
34186 this_ptr_conv.inner = untag_ptr(this_ptr);
34187 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34189 this_ptr_conv.is_owned = false;
34190 LDKUnsignedNodeAnnouncement val_conv;
34191 val_conv.inner = untag_ptr(val);
34192 val_conv.is_owned = ptr_is_owned(val);
34193 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34194 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
34195 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
34198 uint64_t __attribute__((export_name("TS_NodeAnnouncement_new"))) TS_NodeAnnouncement_new(int8_tArray signature_arg, uint64_t contents_arg) {
34199 LDKSignature signature_arg_ref;
34200 CHECK(signature_arg->arr_len == 64);
34201 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
34202 LDKUnsignedNodeAnnouncement contents_arg_conv;
34203 contents_arg_conv.inner = untag_ptr(contents_arg);
34204 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
34205 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
34206 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
34207 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
34208 uint64_t ret_ref = 0;
34209 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34210 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34214 static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
34215 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
34216 uint64_t ret_ref = 0;
34217 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34218 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34221 int64_t __attribute__((export_name("TS_NodeAnnouncement_clone_ptr"))) TS_NodeAnnouncement_clone_ptr(uint64_t arg) {
34222 LDKNodeAnnouncement arg_conv;
34223 arg_conv.inner = untag_ptr(arg);
34224 arg_conv.is_owned = ptr_is_owned(arg);
34225 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34226 arg_conv.is_owned = false;
34227 int64_t ret_conv = NodeAnnouncement_clone_ptr(&arg_conv);
34231 uint64_t __attribute__((export_name("TS_NodeAnnouncement_clone"))) TS_NodeAnnouncement_clone(uint64_t orig) {
34232 LDKNodeAnnouncement orig_conv;
34233 orig_conv.inner = untag_ptr(orig);
34234 orig_conv.is_owned = ptr_is_owned(orig);
34235 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34236 orig_conv.is_owned = false;
34237 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
34238 uint64_t ret_ref = 0;
34239 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34240 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34244 jboolean __attribute__((export_name("TS_NodeAnnouncement_eq"))) TS_NodeAnnouncement_eq(uint64_t a, uint64_t b) {
34245 LDKNodeAnnouncement a_conv;
34246 a_conv.inner = untag_ptr(a);
34247 a_conv.is_owned = ptr_is_owned(a);
34248 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34249 a_conv.is_owned = false;
34250 LDKNodeAnnouncement b_conv;
34251 b_conv.inner = untag_ptr(b);
34252 b_conv.is_owned = ptr_is_owned(b);
34253 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34254 b_conv.is_owned = false;
34255 jboolean ret_conv = NodeAnnouncement_eq(&a_conv, &b_conv);
34259 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_free"))) TS_UnsignedChannelAnnouncement_free(uint64_t this_obj) {
34260 LDKUnsignedChannelAnnouncement this_obj_conv;
34261 this_obj_conv.inner = untag_ptr(this_obj);
34262 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34264 UnsignedChannelAnnouncement_free(this_obj_conv);
34267 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_features"))) TS_UnsignedChannelAnnouncement_get_features(uint64_t this_ptr) {
34268 LDKUnsignedChannelAnnouncement this_ptr_conv;
34269 this_ptr_conv.inner = untag_ptr(this_ptr);
34270 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34272 this_ptr_conv.is_owned = false;
34273 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
34274 uint64_t ret_ref = 0;
34275 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34276 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34280 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_features"))) TS_UnsignedChannelAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
34281 LDKUnsignedChannelAnnouncement this_ptr_conv;
34282 this_ptr_conv.inner = untag_ptr(this_ptr);
34283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34285 this_ptr_conv.is_owned = false;
34286 LDKChannelFeatures val_conv;
34287 val_conv.inner = untag_ptr(val);
34288 val_conv.is_owned = ptr_is_owned(val);
34289 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34290 val_conv = ChannelFeatures_clone(&val_conv);
34291 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
34294 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_chain_hash"))) TS_UnsignedChannelAnnouncement_get_chain_hash(uint64_t this_ptr) {
34295 LDKUnsignedChannelAnnouncement this_ptr_conv;
34296 this_ptr_conv.inner = untag_ptr(this_ptr);
34297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34299 this_ptr_conv.is_owned = false;
34300 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34301 memcpy(ret_arr->elems, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
34305 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_chain_hash"))) TS_UnsignedChannelAnnouncement_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34306 LDKUnsignedChannelAnnouncement this_ptr_conv;
34307 this_ptr_conv.inner = untag_ptr(this_ptr);
34308 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34310 this_ptr_conv.is_owned = false;
34311 LDKThirtyTwoBytes val_ref;
34312 CHECK(val->arr_len == 32);
34313 memcpy(val_ref.data, val->elems, 32); FREE(val);
34314 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
34317 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_short_channel_id"))) TS_UnsignedChannelAnnouncement_get_short_channel_id(uint64_t this_ptr) {
34318 LDKUnsignedChannelAnnouncement this_ptr_conv;
34319 this_ptr_conv.inner = untag_ptr(this_ptr);
34320 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34321 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34322 this_ptr_conv.is_owned = false;
34323 int64_t ret_conv = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
34327 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_short_channel_id"))) TS_UnsignedChannelAnnouncement_set_short_channel_id(uint64_t this_ptr, int64_t val) {
34328 LDKUnsignedChannelAnnouncement this_ptr_conv;
34329 this_ptr_conv.inner = untag_ptr(this_ptr);
34330 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34332 this_ptr_conv.is_owned = false;
34333 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
34336 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_1"))) TS_UnsignedChannelAnnouncement_get_node_id_1(uint64_t this_ptr) {
34337 LDKUnsignedChannelAnnouncement this_ptr_conv;
34338 this_ptr_conv.inner = untag_ptr(this_ptr);
34339 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34341 this_ptr_conv.is_owned = false;
34342 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv);
34343 uint64_t ret_ref = 0;
34344 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34345 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34349 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_1"))) TS_UnsignedChannelAnnouncement_set_node_id_1(uint64_t this_ptr, uint64_t val) {
34350 LDKUnsignedChannelAnnouncement this_ptr_conv;
34351 this_ptr_conv.inner = untag_ptr(this_ptr);
34352 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34354 this_ptr_conv.is_owned = false;
34355 LDKNodeId val_conv;
34356 val_conv.inner = untag_ptr(val);
34357 val_conv.is_owned = ptr_is_owned(val);
34358 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34359 val_conv = NodeId_clone(&val_conv);
34360 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_conv);
34363 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_2"))) TS_UnsignedChannelAnnouncement_get_node_id_2(uint64_t this_ptr) {
34364 LDKUnsignedChannelAnnouncement this_ptr_conv;
34365 this_ptr_conv.inner = untag_ptr(this_ptr);
34366 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34367 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34368 this_ptr_conv.is_owned = false;
34369 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv);
34370 uint64_t ret_ref = 0;
34371 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34372 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34376 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_2"))) TS_UnsignedChannelAnnouncement_set_node_id_2(uint64_t this_ptr, uint64_t val) {
34377 LDKUnsignedChannelAnnouncement this_ptr_conv;
34378 this_ptr_conv.inner = untag_ptr(this_ptr);
34379 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34380 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34381 this_ptr_conv.is_owned = false;
34382 LDKNodeId val_conv;
34383 val_conv.inner = untag_ptr(val);
34384 val_conv.is_owned = ptr_is_owned(val);
34385 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34386 val_conv = NodeId_clone(&val_conv);
34387 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_conv);
34390 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(uint64_t this_ptr) {
34391 LDKUnsignedChannelAnnouncement this_ptr_conv;
34392 this_ptr_conv.inner = untag_ptr(this_ptr);
34393 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34394 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34395 this_ptr_conv.is_owned = false;
34396 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv);
34397 uint64_t ret_ref = 0;
34398 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34399 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34403 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(uint64_t this_ptr, uint64_t val) {
34404 LDKUnsignedChannelAnnouncement this_ptr_conv;
34405 this_ptr_conv.inner = untag_ptr(this_ptr);
34406 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34408 this_ptr_conv.is_owned = false;
34409 LDKNodeId val_conv;
34410 val_conv.inner = untag_ptr(val);
34411 val_conv.is_owned = ptr_is_owned(val);
34412 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34413 val_conv = NodeId_clone(&val_conv);
34414 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_conv);
34417 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(uint64_t this_ptr) {
34418 LDKUnsignedChannelAnnouncement this_ptr_conv;
34419 this_ptr_conv.inner = untag_ptr(this_ptr);
34420 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34421 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34422 this_ptr_conv.is_owned = false;
34423 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv);
34424 uint64_t ret_ref = 0;
34425 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34426 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34430 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(uint64_t this_ptr, uint64_t val) {
34431 LDKUnsignedChannelAnnouncement this_ptr_conv;
34432 this_ptr_conv.inner = untag_ptr(this_ptr);
34433 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34435 this_ptr_conv.is_owned = false;
34436 LDKNodeId val_conv;
34437 val_conv.inner = untag_ptr(val);
34438 val_conv.is_owned = ptr_is_owned(val);
34439 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34440 val_conv = NodeId_clone(&val_conv);
34441 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_conv);
34444 static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
34445 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
34446 uint64_t ret_ref = 0;
34447 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34448 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34451 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone_ptr"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint64_t arg) {
34452 LDKUnsignedChannelAnnouncement arg_conv;
34453 arg_conv.inner = untag_ptr(arg);
34454 arg_conv.is_owned = ptr_is_owned(arg);
34455 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34456 arg_conv.is_owned = false;
34457 int64_t ret_conv = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
34461 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone"))) TS_UnsignedChannelAnnouncement_clone(uint64_t orig) {
34462 LDKUnsignedChannelAnnouncement orig_conv;
34463 orig_conv.inner = untag_ptr(orig);
34464 orig_conv.is_owned = ptr_is_owned(orig);
34465 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34466 orig_conv.is_owned = false;
34467 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
34468 uint64_t ret_ref = 0;
34469 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34470 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34474 jboolean __attribute__((export_name("TS_UnsignedChannelAnnouncement_eq"))) TS_UnsignedChannelAnnouncement_eq(uint64_t a, uint64_t b) {
34475 LDKUnsignedChannelAnnouncement a_conv;
34476 a_conv.inner = untag_ptr(a);
34477 a_conv.is_owned = ptr_is_owned(a);
34478 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34479 a_conv.is_owned = false;
34480 LDKUnsignedChannelAnnouncement b_conv;
34481 b_conv.inner = untag_ptr(b);
34482 b_conv.is_owned = ptr_is_owned(b);
34483 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34484 b_conv.is_owned = false;
34485 jboolean ret_conv = UnsignedChannelAnnouncement_eq(&a_conv, &b_conv);
34489 void __attribute__((export_name("TS_ChannelAnnouncement_free"))) TS_ChannelAnnouncement_free(uint64_t this_obj) {
34490 LDKChannelAnnouncement this_obj_conv;
34491 this_obj_conv.inner = untag_ptr(this_obj);
34492 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34494 ChannelAnnouncement_free(this_obj_conv);
34497 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_1"))) TS_ChannelAnnouncement_get_node_signature_1(uint64_t this_ptr) {
34498 LDKChannelAnnouncement this_ptr_conv;
34499 this_ptr_conv.inner = untag_ptr(this_ptr);
34500 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34501 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34502 this_ptr_conv.is_owned = false;
34503 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34504 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
34508 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_1"))) TS_ChannelAnnouncement_set_node_signature_1(uint64_t this_ptr, int8_tArray val) {
34509 LDKChannelAnnouncement this_ptr_conv;
34510 this_ptr_conv.inner = untag_ptr(this_ptr);
34511 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34512 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34513 this_ptr_conv.is_owned = false;
34514 LDKSignature val_ref;
34515 CHECK(val->arr_len == 64);
34516 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34517 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
34520 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_2"))) TS_ChannelAnnouncement_get_node_signature_2(uint64_t this_ptr) {
34521 LDKChannelAnnouncement this_ptr_conv;
34522 this_ptr_conv.inner = untag_ptr(this_ptr);
34523 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34524 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34525 this_ptr_conv.is_owned = false;
34526 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34527 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
34531 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_2"))) TS_ChannelAnnouncement_set_node_signature_2(uint64_t this_ptr, int8_tArray val) {
34532 LDKChannelAnnouncement this_ptr_conv;
34533 this_ptr_conv.inner = untag_ptr(this_ptr);
34534 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34535 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34536 this_ptr_conv.is_owned = false;
34537 LDKSignature val_ref;
34538 CHECK(val->arr_len == 64);
34539 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34540 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
34543 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_1"))) TS_ChannelAnnouncement_get_bitcoin_signature_1(uint64_t this_ptr) {
34544 LDKChannelAnnouncement this_ptr_conv;
34545 this_ptr_conv.inner = untag_ptr(this_ptr);
34546 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34548 this_ptr_conv.is_owned = false;
34549 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34550 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
34554 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_1"))) TS_ChannelAnnouncement_set_bitcoin_signature_1(uint64_t this_ptr, int8_tArray val) {
34555 LDKChannelAnnouncement this_ptr_conv;
34556 this_ptr_conv.inner = untag_ptr(this_ptr);
34557 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34558 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34559 this_ptr_conv.is_owned = false;
34560 LDKSignature val_ref;
34561 CHECK(val->arr_len == 64);
34562 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34563 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
34566 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_2"))) TS_ChannelAnnouncement_get_bitcoin_signature_2(uint64_t this_ptr) {
34567 LDKChannelAnnouncement this_ptr_conv;
34568 this_ptr_conv.inner = untag_ptr(this_ptr);
34569 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34570 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34571 this_ptr_conv.is_owned = false;
34572 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34573 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
34577 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_2"))) TS_ChannelAnnouncement_set_bitcoin_signature_2(uint64_t this_ptr, int8_tArray val) {
34578 LDKChannelAnnouncement this_ptr_conv;
34579 this_ptr_conv.inner = untag_ptr(this_ptr);
34580 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34582 this_ptr_conv.is_owned = false;
34583 LDKSignature val_ref;
34584 CHECK(val->arr_len == 64);
34585 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34586 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
34589 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_get_contents"))) TS_ChannelAnnouncement_get_contents(uint64_t this_ptr) {
34590 LDKChannelAnnouncement this_ptr_conv;
34591 this_ptr_conv.inner = untag_ptr(this_ptr);
34592 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34594 this_ptr_conv.is_owned = false;
34595 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
34596 uint64_t ret_ref = 0;
34597 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34598 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34602 void __attribute__((export_name("TS_ChannelAnnouncement_set_contents"))) TS_ChannelAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
34603 LDKChannelAnnouncement this_ptr_conv;
34604 this_ptr_conv.inner = untag_ptr(this_ptr);
34605 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34607 this_ptr_conv.is_owned = false;
34608 LDKUnsignedChannelAnnouncement val_conv;
34609 val_conv.inner = untag_ptr(val);
34610 val_conv.is_owned = ptr_is_owned(val);
34611 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34612 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
34613 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
34616 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) {
34617 LDKSignature node_signature_1_arg_ref;
34618 CHECK(node_signature_1_arg->arr_len == 64);
34619 memcpy(node_signature_1_arg_ref.compact_form, node_signature_1_arg->elems, 64); FREE(node_signature_1_arg);
34620 LDKSignature node_signature_2_arg_ref;
34621 CHECK(node_signature_2_arg->arr_len == 64);
34622 memcpy(node_signature_2_arg_ref.compact_form, node_signature_2_arg->elems, 64); FREE(node_signature_2_arg);
34623 LDKSignature bitcoin_signature_1_arg_ref;
34624 CHECK(bitcoin_signature_1_arg->arr_len == 64);
34625 memcpy(bitcoin_signature_1_arg_ref.compact_form, bitcoin_signature_1_arg->elems, 64); FREE(bitcoin_signature_1_arg);
34626 LDKSignature bitcoin_signature_2_arg_ref;
34627 CHECK(bitcoin_signature_2_arg->arr_len == 64);
34628 memcpy(bitcoin_signature_2_arg_ref.compact_form, bitcoin_signature_2_arg->elems, 64); FREE(bitcoin_signature_2_arg);
34629 LDKUnsignedChannelAnnouncement contents_arg_conv;
34630 contents_arg_conv.inner = untag_ptr(contents_arg);
34631 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
34632 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
34633 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
34634 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);
34635 uint64_t ret_ref = 0;
34636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34637 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34641 static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
34642 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
34643 uint64_t ret_ref = 0;
34644 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34645 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34648 int64_t __attribute__((export_name("TS_ChannelAnnouncement_clone_ptr"))) TS_ChannelAnnouncement_clone_ptr(uint64_t arg) {
34649 LDKChannelAnnouncement arg_conv;
34650 arg_conv.inner = untag_ptr(arg);
34651 arg_conv.is_owned = ptr_is_owned(arg);
34652 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34653 arg_conv.is_owned = false;
34654 int64_t ret_conv = ChannelAnnouncement_clone_ptr(&arg_conv);
34658 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_clone"))) TS_ChannelAnnouncement_clone(uint64_t orig) {
34659 LDKChannelAnnouncement orig_conv;
34660 orig_conv.inner = untag_ptr(orig);
34661 orig_conv.is_owned = ptr_is_owned(orig);
34662 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34663 orig_conv.is_owned = false;
34664 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
34665 uint64_t ret_ref = 0;
34666 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34667 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34671 jboolean __attribute__((export_name("TS_ChannelAnnouncement_eq"))) TS_ChannelAnnouncement_eq(uint64_t a, uint64_t b) {
34672 LDKChannelAnnouncement a_conv;
34673 a_conv.inner = untag_ptr(a);
34674 a_conv.is_owned = ptr_is_owned(a);
34675 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34676 a_conv.is_owned = false;
34677 LDKChannelAnnouncement b_conv;
34678 b_conv.inner = untag_ptr(b);
34679 b_conv.is_owned = ptr_is_owned(b);
34680 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34681 b_conv.is_owned = false;
34682 jboolean ret_conv = ChannelAnnouncement_eq(&a_conv, &b_conv);
34686 void __attribute__((export_name("TS_UnsignedChannelUpdate_free"))) TS_UnsignedChannelUpdate_free(uint64_t this_obj) {
34687 LDKUnsignedChannelUpdate this_obj_conv;
34688 this_obj_conv.inner = untag_ptr(this_obj);
34689 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34691 UnsignedChannelUpdate_free(this_obj_conv);
34694 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_chain_hash"))) TS_UnsignedChannelUpdate_get_chain_hash(uint64_t this_ptr) {
34695 LDKUnsignedChannelUpdate this_ptr_conv;
34696 this_ptr_conv.inner = untag_ptr(this_ptr);
34697 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34698 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34699 this_ptr_conv.is_owned = false;
34700 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34701 memcpy(ret_arr->elems, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
34705 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_chain_hash"))) TS_UnsignedChannelUpdate_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
34706 LDKUnsignedChannelUpdate this_ptr_conv;
34707 this_ptr_conv.inner = untag_ptr(this_ptr);
34708 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34710 this_ptr_conv.is_owned = false;
34711 LDKThirtyTwoBytes val_ref;
34712 CHECK(val->arr_len == 32);
34713 memcpy(val_ref.data, val->elems, 32); FREE(val);
34714 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
34717 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_short_channel_id"))) TS_UnsignedChannelUpdate_get_short_channel_id(uint64_t this_ptr) {
34718 LDKUnsignedChannelUpdate this_ptr_conv;
34719 this_ptr_conv.inner = untag_ptr(this_ptr);
34720 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34722 this_ptr_conv.is_owned = false;
34723 int64_t ret_conv = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
34727 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_short_channel_id"))) TS_UnsignedChannelUpdate_set_short_channel_id(uint64_t this_ptr, int64_t val) {
34728 LDKUnsignedChannelUpdate this_ptr_conv;
34729 this_ptr_conv.inner = untag_ptr(this_ptr);
34730 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34732 this_ptr_conv.is_owned = false;
34733 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
34736 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_timestamp"))) TS_UnsignedChannelUpdate_get_timestamp(uint64_t this_ptr) {
34737 LDKUnsignedChannelUpdate this_ptr_conv;
34738 this_ptr_conv.inner = untag_ptr(this_ptr);
34739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34741 this_ptr_conv.is_owned = false;
34742 int32_t ret_conv = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
34746 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_timestamp"))) TS_UnsignedChannelUpdate_set_timestamp(uint64_t this_ptr, int32_t val) {
34747 LDKUnsignedChannelUpdate this_ptr_conv;
34748 this_ptr_conv.inner = untag_ptr(this_ptr);
34749 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34750 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34751 this_ptr_conv.is_owned = false;
34752 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
34755 int8_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_flags"))) TS_UnsignedChannelUpdate_get_flags(uint64_t this_ptr) {
34756 LDKUnsignedChannelUpdate this_ptr_conv;
34757 this_ptr_conv.inner = untag_ptr(this_ptr);
34758 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34759 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34760 this_ptr_conv.is_owned = false;
34761 int8_t ret_conv = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
34765 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_flags"))) TS_UnsignedChannelUpdate_set_flags(uint64_t this_ptr, int8_t val) {
34766 LDKUnsignedChannelUpdate this_ptr_conv;
34767 this_ptr_conv.inner = untag_ptr(this_ptr);
34768 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34770 this_ptr_conv.is_owned = false;
34771 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
34774 int16_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_get_cltv_expiry_delta(uint64_t this_ptr) {
34775 LDKUnsignedChannelUpdate this_ptr_conv;
34776 this_ptr_conv.inner = untag_ptr(this_ptr);
34777 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34779 this_ptr_conv.is_owned = false;
34780 int16_t ret_conv = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
34784 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
34785 LDKUnsignedChannelUpdate this_ptr_conv;
34786 this_ptr_conv.inner = untag_ptr(this_ptr);
34787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34789 this_ptr_conv.is_owned = false;
34790 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
34793 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_get_htlc_minimum_msat(uint64_t this_ptr) {
34794 LDKUnsignedChannelUpdate this_ptr_conv;
34795 this_ptr_conv.inner = untag_ptr(this_ptr);
34796 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34797 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34798 this_ptr_conv.is_owned = false;
34799 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
34803 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
34804 LDKUnsignedChannelUpdate this_ptr_conv;
34805 this_ptr_conv.inner = untag_ptr(this_ptr);
34806 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34808 this_ptr_conv.is_owned = false;
34809 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
34812 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_get_htlc_maximum_msat(uint64_t this_ptr) {
34813 LDKUnsignedChannelUpdate this_ptr_conv;
34814 this_ptr_conv.inner = untag_ptr(this_ptr);
34815 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34816 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34817 this_ptr_conv.is_owned = false;
34818 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_maximum_msat(&this_ptr_conv);
34822 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
34823 LDKUnsignedChannelUpdate this_ptr_conv;
34824 this_ptr_conv.inner = untag_ptr(this_ptr);
34825 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34827 this_ptr_conv.is_owned = false;
34828 UnsignedChannelUpdate_set_htlc_maximum_msat(&this_ptr_conv, val);
34831 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_base_msat"))) TS_UnsignedChannelUpdate_get_fee_base_msat(uint64_t this_ptr) {
34832 LDKUnsignedChannelUpdate this_ptr_conv;
34833 this_ptr_conv.inner = untag_ptr(this_ptr);
34834 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34835 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34836 this_ptr_conv.is_owned = false;
34837 int32_t ret_conv = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
34841 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_base_msat"))) TS_UnsignedChannelUpdate_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
34842 LDKUnsignedChannelUpdate this_ptr_conv;
34843 this_ptr_conv.inner = untag_ptr(this_ptr);
34844 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34846 this_ptr_conv.is_owned = false;
34847 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
34850 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_get_fee_proportional_millionths(uint64_t this_ptr) {
34851 LDKUnsignedChannelUpdate this_ptr_conv;
34852 this_ptr_conv.inner = untag_ptr(this_ptr);
34853 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34854 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34855 this_ptr_conv.is_owned = false;
34856 int32_t ret_conv = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
34860 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
34861 LDKUnsignedChannelUpdate this_ptr_conv;
34862 this_ptr_conv.inner = untag_ptr(this_ptr);
34863 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34865 this_ptr_conv.is_owned = false;
34866 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
34869 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_excess_data"))) TS_UnsignedChannelUpdate_get_excess_data(uint64_t this_ptr) {
34870 LDKUnsignedChannelUpdate this_ptr_conv;
34871 this_ptr_conv.inner = untag_ptr(this_ptr);
34872 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34874 this_ptr_conv.is_owned = false;
34875 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_get_excess_data(&this_ptr_conv);
34876 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34877 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34878 CVec_u8Z_free(ret_var);
34882 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_excess_data"))) TS_UnsignedChannelUpdate_set_excess_data(uint64_t this_ptr, int8_tArray val) {
34883 LDKUnsignedChannelUpdate this_ptr_conv;
34884 this_ptr_conv.inner = untag_ptr(this_ptr);
34885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34887 this_ptr_conv.is_owned = false;
34888 LDKCVec_u8Z val_ref;
34889 val_ref.datalen = val->arr_len;
34890 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
34891 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
34892 UnsignedChannelUpdate_set_excess_data(&this_ptr_conv, val_ref);
34895 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) {
34896 LDKThirtyTwoBytes chain_hash_arg_ref;
34897 CHECK(chain_hash_arg->arr_len == 32);
34898 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
34899 LDKCVec_u8Z excess_data_arg_ref;
34900 excess_data_arg_ref.datalen = excess_data_arg->arr_len;
34901 excess_data_arg_ref.data = MALLOC(excess_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
34902 memcpy(excess_data_arg_ref.data, excess_data_arg->elems, excess_data_arg_ref.datalen); FREE(excess_data_arg);
34903 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);
34904 uint64_t ret_ref = 0;
34905 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34906 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34910 static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
34911 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
34912 uint64_t ret_ref = 0;
34913 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34914 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34917 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone_ptr"))) TS_UnsignedChannelUpdate_clone_ptr(uint64_t arg) {
34918 LDKUnsignedChannelUpdate arg_conv;
34919 arg_conv.inner = untag_ptr(arg);
34920 arg_conv.is_owned = ptr_is_owned(arg);
34921 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34922 arg_conv.is_owned = false;
34923 int64_t ret_conv = UnsignedChannelUpdate_clone_ptr(&arg_conv);
34927 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone"))) TS_UnsignedChannelUpdate_clone(uint64_t orig) {
34928 LDKUnsignedChannelUpdate orig_conv;
34929 orig_conv.inner = untag_ptr(orig);
34930 orig_conv.is_owned = ptr_is_owned(orig);
34931 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34932 orig_conv.is_owned = false;
34933 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
34934 uint64_t ret_ref = 0;
34935 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34936 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34940 jboolean __attribute__((export_name("TS_UnsignedChannelUpdate_eq"))) TS_UnsignedChannelUpdate_eq(uint64_t a, uint64_t b) {
34941 LDKUnsignedChannelUpdate a_conv;
34942 a_conv.inner = untag_ptr(a);
34943 a_conv.is_owned = ptr_is_owned(a);
34944 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
34945 a_conv.is_owned = false;
34946 LDKUnsignedChannelUpdate b_conv;
34947 b_conv.inner = untag_ptr(b);
34948 b_conv.is_owned = ptr_is_owned(b);
34949 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
34950 b_conv.is_owned = false;
34951 jboolean ret_conv = UnsignedChannelUpdate_eq(&a_conv, &b_conv);
34955 void __attribute__((export_name("TS_ChannelUpdate_free"))) TS_ChannelUpdate_free(uint64_t this_obj) {
34956 LDKChannelUpdate this_obj_conv;
34957 this_obj_conv.inner = untag_ptr(this_obj);
34958 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34960 ChannelUpdate_free(this_obj_conv);
34963 int8_tArray __attribute__((export_name("TS_ChannelUpdate_get_signature"))) TS_ChannelUpdate_get_signature(uint64_t this_ptr) {
34964 LDKChannelUpdate this_ptr_conv;
34965 this_ptr_conv.inner = untag_ptr(this_ptr);
34966 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34968 this_ptr_conv.is_owned = false;
34969 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
34970 memcpy(ret_arr->elems, ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
34974 void __attribute__((export_name("TS_ChannelUpdate_set_signature"))) TS_ChannelUpdate_set_signature(uint64_t this_ptr, int8_tArray val) {
34975 LDKChannelUpdate this_ptr_conv;
34976 this_ptr_conv.inner = untag_ptr(this_ptr);
34977 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34979 this_ptr_conv.is_owned = false;
34980 LDKSignature val_ref;
34981 CHECK(val->arr_len == 64);
34982 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
34983 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
34986 uint64_t __attribute__((export_name("TS_ChannelUpdate_get_contents"))) TS_ChannelUpdate_get_contents(uint64_t this_ptr) {
34987 LDKChannelUpdate this_ptr_conv;
34988 this_ptr_conv.inner = untag_ptr(this_ptr);
34989 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34991 this_ptr_conv.is_owned = false;
34992 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
34993 uint64_t ret_ref = 0;
34994 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34995 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34999 void __attribute__((export_name("TS_ChannelUpdate_set_contents"))) TS_ChannelUpdate_set_contents(uint64_t this_ptr, uint64_t val) {
35000 LDKChannelUpdate this_ptr_conv;
35001 this_ptr_conv.inner = untag_ptr(this_ptr);
35002 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35004 this_ptr_conv.is_owned = false;
35005 LDKUnsignedChannelUpdate val_conv;
35006 val_conv.inner = untag_ptr(val);
35007 val_conv.is_owned = ptr_is_owned(val);
35008 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
35009 val_conv = UnsignedChannelUpdate_clone(&val_conv);
35010 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
35013 uint64_t __attribute__((export_name("TS_ChannelUpdate_new"))) TS_ChannelUpdate_new(int8_tArray signature_arg, uint64_t contents_arg) {
35014 LDKSignature signature_arg_ref;
35015 CHECK(signature_arg->arr_len == 64);
35016 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
35017 LDKUnsignedChannelUpdate contents_arg_conv;
35018 contents_arg_conv.inner = untag_ptr(contents_arg);
35019 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
35020 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
35021 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
35022 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
35023 uint64_t ret_ref = 0;
35024 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35025 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35029 static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
35030 LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
35031 uint64_t ret_ref = 0;
35032 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35033 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35036 int64_t __attribute__((export_name("TS_ChannelUpdate_clone_ptr"))) TS_ChannelUpdate_clone_ptr(uint64_t arg) {
35037 LDKChannelUpdate arg_conv;
35038 arg_conv.inner = untag_ptr(arg);
35039 arg_conv.is_owned = ptr_is_owned(arg);
35040 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35041 arg_conv.is_owned = false;
35042 int64_t ret_conv = ChannelUpdate_clone_ptr(&arg_conv);
35046 uint64_t __attribute__((export_name("TS_ChannelUpdate_clone"))) TS_ChannelUpdate_clone(uint64_t orig) {
35047 LDKChannelUpdate orig_conv;
35048 orig_conv.inner = untag_ptr(orig);
35049 orig_conv.is_owned = ptr_is_owned(orig);
35050 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35051 orig_conv.is_owned = false;
35052 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
35053 uint64_t ret_ref = 0;
35054 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35055 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35059 jboolean __attribute__((export_name("TS_ChannelUpdate_eq"))) TS_ChannelUpdate_eq(uint64_t a, uint64_t b) {
35060 LDKChannelUpdate a_conv;
35061 a_conv.inner = untag_ptr(a);
35062 a_conv.is_owned = ptr_is_owned(a);
35063 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35064 a_conv.is_owned = false;
35065 LDKChannelUpdate b_conv;
35066 b_conv.inner = untag_ptr(b);
35067 b_conv.is_owned = ptr_is_owned(b);
35068 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35069 b_conv.is_owned = false;
35070 jboolean ret_conv = ChannelUpdate_eq(&a_conv, &b_conv);
35074 void __attribute__((export_name("TS_QueryChannelRange_free"))) TS_QueryChannelRange_free(uint64_t this_obj) {
35075 LDKQueryChannelRange this_obj_conv;
35076 this_obj_conv.inner = untag_ptr(this_obj);
35077 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35078 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35079 QueryChannelRange_free(this_obj_conv);
35082 int8_tArray __attribute__((export_name("TS_QueryChannelRange_get_chain_hash"))) TS_QueryChannelRange_get_chain_hash(uint64_t this_ptr) {
35083 LDKQueryChannelRange this_ptr_conv;
35084 this_ptr_conv.inner = untag_ptr(this_ptr);
35085 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35087 this_ptr_conv.is_owned = false;
35088 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35089 memcpy(ret_arr->elems, *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
35093 void __attribute__((export_name("TS_QueryChannelRange_set_chain_hash"))) TS_QueryChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35094 LDKQueryChannelRange this_ptr_conv;
35095 this_ptr_conv.inner = untag_ptr(this_ptr);
35096 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35098 this_ptr_conv.is_owned = false;
35099 LDKThirtyTwoBytes val_ref;
35100 CHECK(val->arr_len == 32);
35101 memcpy(val_ref.data, val->elems, 32); FREE(val);
35102 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
35105 int32_t __attribute__((export_name("TS_QueryChannelRange_get_first_blocknum"))) TS_QueryChannelRange_get_first_blocknum(uint64_t this_ptr) {
35106 LDKQueryChannelRange this_ptr_conv;
35107 this_ptr_conv.inner = untag_ptr(this_ptr);
35108 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35110 this_ptr_conv.is_owned = false;
35111 int32_t ret_conv = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
35115 void __attribute__((export_name("TS_QueryChannelRange_set_first_blocknum"))) TS_QueryChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
35116 LDKQueryChannelRange this_ptr_conv;
35117 this_ptr_conv.inner = untag_ptr(this_ptr);
35118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35120 this_ptr_conv.is_owned = false;
35121 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
35124 int32_t __attribute__((export_name("TS_QueryChannelRange_get_number_of_blocks"))) TS_QueryChannelRange_get_number_of_blocks(uint64_t this_ptr) {
35125 LDKQueryChannelRange this_ptr_conv;
35126 this_ptr_conv.inner = untag_ptr(this_ptr);
35127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35129 this_ptr_conv.is_owned = false;
35130 int32_t ret_conv = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
35134 void __attribute__((export_name("TS_QueryChannelRange_set_number_of_blocks"))) TS_QueryChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
35135 LDKQueryChannelRange this_ptr_conv;
35136 this_ptr_conv.inner = untag_ptr(this_ptr);
35137 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35139 this_ptr_conv.is_owned = false;
35140 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
35143 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) {
35144 LDKThirtyTwoBytes chain_hash_arg_ref;
35145 CHECK(chain_hash_arg->arr_len == 32);
35146 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35147 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
35148 uint64_t ret_ref = 0;
35149 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35150 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35154 static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
35155 LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
35156 uint64_t ret_ref = 0;
35157 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35158 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35161 int64_t __attribute__((export_name("TS_QueryChannelRange_clone_ptr"))) TS_QueryChannelRange_clone_ptr(uint64_t arg) {
35162 LDKQueryChannelRange arg_conv;
35163 arg_conv.inner = untag_ptr(arg);
35164 arg_conv.is_owned = ptr_is_owned(arg);
35165 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35166 arg_conv.is_owned = false;
35167 int64_t ret_conv = QueryChannelRange_clone_ptr(&arg_conv);
35171 uint64_t __attribute__((export_name("TS_QueryChannelRange_clone"))) TS_QueryChannelRange_clone(uint64_t orig) {
35172 LDKQueryChannelRange orig_conv;
35173 orig_conv.inner = untag_ptr(orig);
35174 orig_conv.is_owned = ptr_is_owned(orig);
35175 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35176 orig_conv.is_owned = false;
35177 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
35178 uint64_t ret_ref = 0;
35179 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35180 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35184 jboolean __attribute__((export_name("TS_QueryChannelRange_eq"))) TS_QueryChannelRange_eq(uint64_t a, uint64_t b) {
35185 LDKQueryChannelRange a_conv;
35186 a_conv.inner = untag_ptr(a);
35187 a_conv.is_owned = ptr_is_owned(a);
35188 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35189 a_conv.is_owned = false;
35190 LDKQueryChannelRange b_conv;
35191 b_conv.inner = untag_ptr(b);
35192 b_conv.is_owned = ptr_is_owned(b);
35193 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35194 b_conv.is_owned = false;
35195 jboolean ret_conv = QueryChannelRange_eq(&a_conv, &b_conv);
35199 void __attribute__((export_name("TS_ReplyChannelRange_free"))) TS_ReplyChannelRange_free(uint64_t this_obj) {
35200 LDKReplyChannelRange this_obj_conv;
35201 this_obj_conv.inner = untag_ptr(this_obj);
35202 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35204 ReplyChannelRange_free(this_obj_conv);
35207 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_get_chain_hash"))) TS_ReplyChannelRange_get_chain_hash(uint64_t this_ptr) {
35208 LDKReplyChannelRange this_ptr_conv;
35209 this_ptr_conv.inner = untag_ptr(this_ptr);
35210 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35212 this_ptr_conv.is_owned = false;
35213 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35214 memcpy(ret_arr->elems, *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
35218 void __attribute__((export_name("TS_ReplyChannelRange_set_chain_hash"))) TS_ReplyChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35219 LDKReplyChannelRange this_ptr_conv;
35220 this_ptr_conv.inner = untag_ptr(this_ptr);
35221 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35222 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35223 this_ptr_conv.is_owned = false;
35224 LDKThirtyTwoBytes val_ref;
35225 CHECK(val->arr_len == 32);
35226 memcpy(val_ref.data, val->elems, 32); FREE(val);
35227 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
35230 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_first_blocknum"))) TS_ReplyChannelRange_get_first_blocknum(uint64_t this_ptr) {
35231 LDKReplyChannelRange this_ptr_conv;
35232 this_ptr_conv.inner = untag_ptr(this_ptr);
35233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35235 this_ptr_conv.is_owned = false;
35236 int32_t ret_conv = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
35240 void __attribute__((export_name("TS_ReplyChannelRange_set_first_blocknum"))) TS_ReplyChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
35241 LDKReplyChannelRange this_ptr_conv;
35242 this_ptr_conv.inner = untag_ptr(this_ptr);
35243 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35245 this_ptr_conv.is_owned = false;
35246 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
35249 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_number_of_blocks"))) TS_ReplyChannelRange_get_number_of_blocks(uint64_t this_ptr) {
35250 LDKReplyChannelRange this_ptr_conv;
35251 this_ptr_conv.inner = untag_ptr(this_ptr);
35252 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35254 this_ptr_conv.is_owned = false;
35255 int32_t ret_conv = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
35259 void __attribute__((export_name("TS_ReplyChannelRange_set_number_of_blocks"))) TS_ReplyChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
35260 LDKReplyChannelRange this_ptr_conv;
35261 this_ptr_conv.inner = untag_ptr(this_ptr);
35262 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35264 this_ptr_conv.is_owned = false;
35265 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
35268 jboolean __attribute__((export_name("TS_ReplyChannelRange_get_sync_complete"))) TS_ReplyChannelRange_get_sync_complete(uint64_t this_ptr) {
35269 LDKReplyChannelRange this_ptr_conv;
35270 this_ptr_conv.inner = untag_ptr(this_ptr);
35271 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35272 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35273 this_ptr_conv.is_owned = false;
35274 jboolean ret_conv = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
35278 void __attribute__((export_name("TS_ReplyChannelRange_set_sync_complete"))) TS_ReplyChannelRange_set_sync_complete(uint64_t this_ptr, jboolean val) {
35279 LDKReplyChannelRange this_ptr_conv;
35280 this_ptr_conv.inner = untag_ptr(this_ptr);
35281 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35282 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35283 this_ptr_conv.is_owned = false;
35284 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
35287 int64_tArray __attribute__((export_name("TS_ReplyChannelRange_get_short_channel_ids"))) TS_ReplyChannelRange_get_short_channel_ids(uint64_t this_ptr) {
35288 LDKReplyChannelRange this_ptr_conv;
35289 this_ptr_conv.inner = untag_ptr(this_ptr);
35290 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35291 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35292 this_ptr_conv.is_owned = false;
35293 LDKCVec_u64Z ret_var = ReplyChannelRange_get_short_channel_ids(&this_ptr_conv);
35294 int64_tArray ret_arr = NULL;
35295 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
35296 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
35297 for (size_t i = 0; i < ret_var.datalen; i++) {
35298 int64_t ret_conv_8_conv = ret_var.data[i];
35299 ret_arr_ptr[i] = ret_conv_8_conv;
35302 FREE(ret_var.data);
35306 void __attribute__((export_name("TS_ReplyChannelRange_set_short_channel_ids"))) TS_ReplyChannelRange_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
35307 LDKReplyChannelRange this_ptr_conv;
35308 this_ptr_conv.inner = untag_ptr(this_ptr);
35309 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35310 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35311 this_ptr_conv.is_owned = false;
35312 LDKCVec_u64Z val_constr;
35313 val_constr.datalen = val->arr_len;
35314 if (val_constr.datalen > 0)
35315 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35317 val_constr.data = NULL;
35318 int64_t* val_vals = val->elems;
35319 for (size_t i = 0; i < val_constr.datalen; i++) {
35320 int64_t val_conv_8 = val_vals[i];
35321 val_constr.data[i] = val_conv_8;
35324 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
35327 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) {
35328 LDKThirtyTwoBytes chain_hash_arg_ref;
35329 CHECK(chain_hash_arg->arr_len == 32);
35330 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35331 LDKCVec_u64Z short_channel_ids_arg_constr;
35332 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
35333 if (short_channel_ids_arg_constr.datalen > 0)
35334 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35336 short_channel_ids_arg_constr.data = NULL;
35337 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
35338 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
35339 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
35340 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
35342 FREE(short_channel_ids_arg);
35343 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
35344 uint64_t ret_ref = 0;
35345 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35346 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35350 static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
35351 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
35352 uint64_t ret_ref = 0;
35353 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35354 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35357 int64_t __attribute__((export_name("TS_ReplyChannelRange_clone_ptr"))) TS_ReplyChannelRange_clone_ptr(uint64_t arg) {
35358 LDKReplyChannelRange arg_conv;
35359 arg_conv.inner = untag_ptr(arg);
35360 arg_conv.is_owned = ptr_is_owned(arg);
35361 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35362 arg_conv.is_owned = false;
35363 int64_t ret_conv = ReplyChannelRange_clone_ptr(&arg_conv);
35367 uint64_t __attribute__((export_name("TS_ReplyChannelRange_clone"))) TS_ReplyChannelRange_clone(uint64_t orig) {
35368 LDKReplyChannelRange orig_conv;
35369 orig_conv.inner = untag_ptr(orig);
35370 orig_conv.is_owned = ptr_is_owned(orig);
35371 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35372 orig_conv.is_owned = false;
35373 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
35374 uint64_t ret_ref = 0;
35375 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35376 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35380 jboolean __attribute__((export_name("TS_ReplyChannelRange_eq"))) TS_ReplyChannelRange_eq(uint64_t a, uint64_t b) {
35381 LDKReplyChannelRange a_conv;
35382 a_conv.inner = untag_ptr(a);
35383 a_conv.is_owned = ptr_is_owned(a);
35384 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35385 a_conv.is_owned = false;
35386 LDKReplyChannelRange b_conv;
35387 b_conv.inner = untag_ptr(b);
35388 b_conv.is_owned = ptr_is_owned(b);
35389 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35390 b_conv.is_owned = false;
35391 jboolean ret_conv = ReplyChannelRange_eq(&a_conv, &b_conv);
35395 void __attribute__((export_name("TS_QueryShortChannelIds_free"))) TS_QueryShortChannelIds_free(uint64_t this_obj) {
35396 LDKQueryShortChannelIds this_obj_conv;
35397 this_obj_conv.inner = untag_ptr(this_obj);
35398 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35400 QueryShortChannelIds_free(this_obj_conv);
35403 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_chain_hash"))) TS_QueryShortChannelIds_get_chain_hash(uint64_t this_ptr) {
35404 LDKQueryShortChannelIds this_ptr_conv;
35405 this_ptr_conv.inner = untag_ptr(this_ptr);
35406 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35408 this_ptr_conv.is_owned = false;
35409 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35410 memcpy(ret_arr->elems, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
35414 void __attribute__((export_name("TS_QueryShortChannelIds_set_chain_hash"))) TS_QueryShortChannelIds_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35415 LDKQueryShortChannelIds this_ptr_conv;
35416 this_ptr_conv.inner = untag_ptr(this_ptr);
35417 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35418 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35419 this_ptr_conv.is_owned = false;
35420 LDKThirtyTwoBytes val_ref;
35421 CHECK(val->arr_len == 32);
35422 memcpy(val_ref.data, val->elems, 32); FREE(val);
35423 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
35426 int64_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_short_channel_ids"))) TS_QueryShortChannelIds_get_short_channel_ids(uint64_t this_ptr) {
35427 LDKQueryShortChannelIds this_ptr_conv;
35428 this_ptr_conv.inner = untag_ptr(this_ptr);
35429 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35430 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35431 this_ptr_conv.is_owned = false;
35432 LDKCVec_u64Z ret_var = QueryShortChannelIds_get_short_channel_ids(&this_ptr_conv);
35433 int64_tArray ret_arr = NULL;
35434 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
35435 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
35436 for (size_t i = 0; i < ret_var.datalen; i++) {
35437 int64_t ret_conv_8_conv = ret_var.data[i];
35438 ret_arr_ptr[i] = ret_conv_8_conv;
35441 FREE(ret_var.data);
35445 void __attribute__((export_name("TS_QueryShortChannelIds_set_short_channel_ids"))) TS_QueryShortChannelIds_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
35446 LDKQueryShortChannelIds this_ptr_conv;
35447 this_ptr_conv.inner = untag_ptr(this_ptr);
35448 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35450 this_ptr_conv.is_owned = false;
35451 LDKCVec_u64Z val_constr;
35452 val_constr.datalen = val->arr_len;
35453 if (val_constr.datalen > 0)
35454 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35456 val_constr.data = NULL;
35457 int64_t* val_vals = val->elems;
35458 for (size_t i = 0; i < val_constr.datalen; i++) {
35459 int64_t val_conv_8 = val_vals[i];
35460 val_constr.data[i] = val_conv_8;
35463 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
35466 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_new"))) TS_QueryShortChannelIds_new(int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
35467 LDKThirtyTwoBytes chain_hash_arg_ref;
35468 CHECK(chain_hash_arg->arr_len == 32);
35469 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35470 LDKCVec_u64Z short_channel_ids_arg_constr;
35471 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
35472 if (short_channel_ids_arg_constr.datalen > 0)
35473 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
35475 short_channel_ids_arg_constr.data = NULL;
35476 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
35477 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
35478 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
35479 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
35481 FREE(short_channel_ids_arg);
35482 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
35483 uint64_t ret_ref = 0;
35484 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35485 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35489 static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
35490 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
35491 uint64_t ret_ref = 0;
35492 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35493 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35496 int64_t __attribute__((export_name("TS_QueryShortChannelIds_clone_ptr"))) TS_QueryShortChannelIds_clone_ptr(uint64_t arg) {
35497 LDKQueryShortChannelIds arg_conv;
35498 arg_conv.inner = untag_ptr(arg);
35499 arg_conv.is_owned = ptr_is_owned(arg);
35500 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35501 arg_conv.is_owned = false;
35502 int64_t ret_conv = QueryShortChannelIds_clone_ptr(&arg_conv);
35506 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_clone"))) TS_QueryShortChannelIds_clone(uint64_t orig) {
35507 LDKQueryShortChannelIds orig_conv;
35508 orig_conv.inner = untag_ptr(orig);
35509 orig_conv.is_owned = ptr_is_owned(orig);
35510 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35511 orig_conv.is_owned = false;
35512 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
35513 uint64_t ret_ref = 0;
35514 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35515 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35519 jboolean __attribute__((export_name("TS_QueryShortChannelIds_eq"))) TS_QueryShortChannelIds_eq(uint64_t a, uint64_t b) {
35520 LDKQueryShortChannelIds a_conv;
35521 a_conv.inner = untag_ptr(a);
35522 a_conv.is_owned = ptr_is_owned(a);
35523 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35524 a_conv.is_owned = false;
35525 LDKQueryShortChannelIds b_conv;
35526 b_conv.inner = untag_ptr(b);
35527 b_conv.is_owned = ptr_is_owned(b);
35528 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35529 b_conv.is_owned = false;
35530 jboolean ret_conv = QueryShortChannelIds_eq(&a_conv, &b_conv);
35534 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_free"))) TS_ReplyShortChannelIdsEnd_free(uint64_t this_obj) {
35535 LDKReplyShortChannelIdsEnd this_obj_conv;
35536 this_obj_conv.inner = untag_ptr(this_obj);
35537 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35539 ReplyShortChannelIdsEnd_free(this_obj_conv);
35542 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_chain_hash"))) TS_ReplyShortChannelIdsEnd_get_chain_hash(uint64_t this_ptr) {
35543 LDKReplyShortChannelIdsEnd this_ptr_conv;
35544 this_ptr_conv.inner = untag_ptr(this_ptr);
35545 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35547 this_ptr_conv.is_owned = false;
35548 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35549 memcpy(ret_arr->elems, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
35553 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_chain_hash"))) TS_ReplyShortChannelIdsEnd_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35554 LDKReplyShortChannelIdsEnd this_ptr_conv;
35555 this_ptr_conv.inner = untag_ptr(this_ptr);
35556 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35557 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35558 this_ptr_conv.is_owned = false;
35559 LDKThirtyTwoBytes val_ref;
35560 CHECK(val->arr_len == 32);
35561 memcpy(val_ref.data, val->elems, 32); FREE(val);
35562 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
35565 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_full_information"))) TS_ReplyShortChannelIdsEnd_get_full_information(uint64_t this_ptr) {
35566 LDKReplyShortChannelIdsEnd this_ptr_conv;
35567 this_ptr_conv.inner = untag_ptr(this_ptr);
35568 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35569 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35570 this_ptr_conv.is_owned = false;
35571 jboolean ret_conv = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
35575 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_full_information"))) TS_ReplyShortChannelIdsEnd_set_full_information(uint64_t this_ptr, jboolean val) {
35576 LDKReplyShortChannelIdsEnd this_ptr_conv;
35577 this_ptr_conv.inner = untag_ptr(this_ptr);
35578 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35580 this_ptr_conv.is_owned = false;
35581 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
35584 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_new"))) TS_ReplyShortChannelIdsEnd_new(int8_tArray chain_hash_arg, jboolean full_information_arg) {
35585 LDKThirtyTwoBytes chain_hash_arg_ref;
35586 CHECK(chain_hash_arg->arr_len == 32);
35587 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35588 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
35589 uint64_t ret_ref = 0;
35590 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35591 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35595 static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
35596 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
35597 uint64_t ret_ref = 0;
35598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35599 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35602 int64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone_ptr"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint64_t arg) {
35603 LDKReplyShortChannelIdsEnd arg_conv;
35604 arg_conv.inner = untag_ptr(arg);
35605 arg_conv.is_owned = ptr_is_owned(arg);
35606 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35607 arg_conv.is_owned = false;
35608 int64_t ret_conv = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
35612 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone"))) TS_ReplyShortChannelIdsEnd_clone(uint64_t orig) {
35613 LDKReplyShortChannelIdsEnd orig_conv;
35614 orig_conv.inner = untag_ptr(orig);
35615 orig_conv.is_owned = ptr_is_owned(orig);
35616 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35617 orig_conv.is_owned = false;
35618 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
35619 uint64_t ret_ref = 0;
35620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35625 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_eq"))) TS_ReplyShortChannelIdsEnd_eq(uint64_t a, uint64_t b) {
35626 LDKReplyShortChannelIdsEnd a_conv;
35627 a_conv.inner = untag_ptr(a);
35628 a_conv.is_owned = ptr_is_owned(a);
35629 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35630 a_conv.is_owned = false;
35631 LDKReplyShortChannelIdsEnd b_conv;
35632 b_conv.inner = untag_ptr(b);
35633 b_conv.is_owned = ptr_is_owned(b);
35634 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35635 b_conv.is_owned = false;
35636 jboolean ret_conv = ReplyShortChannelIdsEnd_eq(&a_conv, &b_conv);
35640 void __attribute__((export_name("TS_GossipTimestampFilter_free"))) TS_GossipTimestampFilter_free(uint64_t this_obj) {
35641 LDKGossipTimestampFilter this_obj_conv;
35642 this_obj_conv.inner = untag_ptr(this_obj);
35643 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35645 GossipTimestampFilter_free(this_obj_conv);
35648 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_get_chain_hash"))) TS_GossipTimestampFilter_get_chain_hash(uint64_t this_ptr) {
35649 LDKGossipTimestampFilter this_ptr_conv;
35650 this_ptr_conv.inner = untag_ptr(this_ptr);
35651 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35652 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35653 this_ptr_conv.is_owned = false;
35654 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35655 memcpy(ret_arr->elems, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
35659 void __attribute__((export_name("TS_GossipTimestampFilter_set_chain_hash"))) TS_GossipTimestampFilter_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
35660 LDKGossipTimestampFilter this_ptr_conv;
35661 this_ptr_conv.inner = untag_ptr(this_ptr);
35662 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35664 this_ptr_conv.is_owned = false;
35665 LDKThirtyTwoBytes val_ref;
35666 CHECK(val->arr_len == 32);
35667 memcpy(val_ref.data, val->elems, 32); FREE(val);
35668 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
35671 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_first_timestamp"))) TS_GossipTimestampFilter_get_first_timestamp(uint64_t this_ptr) {
35672 LDKGossipTimestampFilter this_ptr_conv;
35673 this_ptr_conv.inner = untag_ptr(this_ptr);
35674 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35675 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35676 this_ptr_conv.is_owned = false;
35677 int32_t ret_conv = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
35681 void __attribute__((export_name("TS_GossipTimestampFilter_set_first_timestamp"))) TS_GossipTimestampFilter_set_first_timestamp(uint64_t this_ptr, int32_t val) {
35682 LDKGossipTimestampFilter this_ptr_conv;
35683 this_ptr_conv.inner = untag_ptr(this_ptr);
35684 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35686 this_ptr_conv.is_owned = false;
35687 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
35690 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_timestamp_range"))) TS_GossipTimestampFilter_get_timestamp_range(uint64_t this_ptr) {
35691 LDKGossipTimestampFilter this_ptr_conv;
35692 this_ptr_conv.inner = untag_ptr(this_ptr);
35693 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35695 this_ptr_conv.is_owned = false;
35696 int32_t ret_conv = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
35700 void __attribute__((export_name("TS_GossipTimestampFilter_set_timestamp_range"))) TS_GossipTimestampFilter_set_timestamp_range(uint64_t this_ptr, int32_t val) {
35701 LDKGossipTimestampFilter this_ptr_conv;
35702 this_ptr_conv.inner = untag_ptr(this_ptr);
35703 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35704 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35705 this_ptr_conv.is_owned = false;
35706 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
35709 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) {
35710 LDKThirtyTwoBytes chain_hash_arg_ref;
35711 CHECK(chain_hash_arg->arr_len == 32);
35712 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
35713 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
35714 uint64_t ret_ref = 0;
35715 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35716 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35720 static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
35721 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
35722 uint64_t ret_ref = 0;
35723 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35724 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35727 int64_t __attribute__((export_name("TS_GossipTimestampFilter_clone_ptr"))) TS_GossipTimestampFilter_clone_ptr(uint64_t arg) {
35728 LDKGossipTimestampFilter arg_conv;
35729 arg_conv.inner = untag_ptr(arg);
35730 arg_conv.is_owned = ptr_is_owned(arg);
35731 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35732 arg_conv.is_owned = false;
35733 int64_t ret_conv = GossipTimestampFilter_clone_ptr(&arg_conv);
35737 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_clone"))) TS_GossipTimestampFilter_clone(uint64_t orig) {
35738 LDKGossipTimestampFilter orig_conv;
35739 orig_conv.inner = untag_ptr(orig);
35740 orig_conv.is_owned = ptr_is_owned(orig);
35741 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35742 orig_conv.is_owned = false;
35743 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
35744 uint64_t ret_ref = 0;
35745 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35746 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35750 jboolean __attribute__((export_name("TS_GossipTimestampFilter_eq"))) TS_GossipTimestampFilter_eq(uint64_t a, uint64_t b) {
35751 LDKGossipTimestampFilter a_conv;
35752 a_conv.inner = untag_ptr(a);
35753 a_conv.is_owned = ptr_is_owned(a);
35754 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
35755 a_conv.is_owned = false;
35756 LDKGossipTimestampFilter b_conv;
35757 b_conv.inner = untag_ptr(b);
35758 b_conv.is_owned = ptr_is_owned(b);
35759 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
35760 b_conv.is_owned = false;
35761 jboolean ret_conv = GossipTimestampFilter_eq(&a_conv, &b_conv);
35765 void __attribute__((export_name("TS_ErrorAction_free"))) TS_ErrorAction_free(uint64_t this_ptr) {
35766 if (!ptr_is_owned(this_ptr)) return;
35767 void* this_ptr_ptr = untag_ptr(this_ptr);
35768 CHECK_ACCESS(this_ptr_ptr);
35769 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(this_ptr_ptr);
35770 FREE(untag_ptr(this_ptr));
35771 ErrorAction_free(this_ptr_conv);
35774 static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
35775 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35776 *ret_copy = ErrorAction_clone(arg);
35777 uint64_t ret_ref = tag_ptr(ret_copy, true);
35780 int64_t __attribute__((export_name("TS_ErrorAction_clone_ptr"))) TS_ErrorAction_clone_ptr(uint64_t arg) {
35781 LDKErrorAction* arg_conv = (LDKErrorAction*)untag_ptr(arg);
35782 int64_t ret_conv = ErrorAction_clone_ptr(arg_conv);
35786 uint64_t __attribute__((export_name("TS_ErrorAction_clone"))) TS_ErrorAction_clone(uint64_t orig) {
35787 LDKErrorAction* orig_conv = (LDKErrorAction*)untag_ptr(orig);
35788 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35789 *ret_copy = ErrorAction_clone(orig_conv);
35790 uint64_t ret_ref = tag_ptr(ret_copy, true);
35794 uint64_t __attribute__((export_name("TS_ErrorAction_disconnect_peer"))) TS_ErrorAction_disconnect_peer(uint64_t msg) {
35795 LDKErrorMessage msg_conv;
35796 msg_conv.inner = untag_ptr(msg);
35797 msg_conv.is_owned = ptr_is_owned(msg);
35798 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35799 msg_conv = ErrorMessage_clone(&msg_conv);
35800 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35801 *ret_copy = ErrorAction_disconnect_peer(msg_conv);
35802 uint64_t ret_ref = tag_ptr(ret_copy, true);
35806 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_error"))) TS_ErrorAction_ignore_error() {
35807 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35808 *ret_copy = ErrorAction_ignore_error();
35809 uint64_t ret_ref = tag_ptr(ret_copy, true);
35813 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_and_log"))) TS_ErrorAction_ignore_and_log(uint32_t a) {
35814 LDKLevel a_conv = LDKLevel_from_js(a);
35815 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35816 *ret_copy = ErrorAction_ignore_and_log(a_conv);
35817 uint64_t ret_ref = tag_ptr(ret_copy, true);
35821 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_duplicate_gossip"))) TS_ErrorAction_ignore_duplicate_gossip() {
35822 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35823 *ret_copy = ErrorAction_ignore_duplicate_gossip();
35824 uint64_t ret_ref = tag_ptr(ret_copy, true);
35828 uint64_t __attribute__((export_name("TS_ErrorAction_send_error_message"))) TS_ErrorAction_send_error_message(uint64_t msg) {
35829 LDKErrorMessage msg_conv;
35830 msg_conv.inner = untag_ptr(msg);
35831 msg_conv.is_owned = ptr_is_owned(msg);
35832 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35833 msg_conv = ErrorMessage_clone(&msg_conv);
35834 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35835 *ret_copy = ErrorAction_send_error_message(msg_conv);
35836 uint64_t ret_ref = tag_ptr(ret_copy, true);
35840 uint64_t __attribute__((export_name("TS_ErrorAction_send_warning_message"))) TS_ErrorAction_send_warning_message(uint64_t msg, uint32_t log_level) {
35841 LDKWarningMessage msg_conv;
35842 msg_conv.inner = untag_ptr(msg);
35843 msg_conv.is_owned = ptr_is_owned(msg);
35844 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
35845 msg_conv = WarningMessage_clone(&msg_conv);
35846 LDKLevel log_level_conv = LDKLevel_from_js(log_level);
35847 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35848 *ret_copy = ErrorAction_send_warning_message(msg_conv, log_level_conv);
35849 uint64_t ret_ref = tag_ptr(ret_copy, true);
35853 void __attribute__((export_name("TS_LightningError_free"))) TS_LightningError_free(uint64_t this_obj) {
35854 LDKLightningError this_obj_conv;
35855 this_obj_conv.inner = untag_ptr(this_obj);
35856 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35858 LightningError_free(this_obj_conv);
35861 jstring __attribute__((export_name("TS_LightningError_get_err"))) TS_LightningError_get_err(uint64_t this_ptr) {
35862 LDKLightningError this_ptr_conv;
35863 this_ptr_conv.inner = untag_ptr(this_ptr);
35864 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35866 this_ptr_conv.is_owned = false;
35867 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
35868 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
35873 void __attribute__((export_name("TS_LightningError_set_err"))) TS_LightningError_set_err(uint64_t this_ptr, jstring val) {
35874 LDKLightningError this_ptr_conv;
35875 this_ptr_conv.inner = untag_ptr(this_ptr);
35876 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35878 this_ptr_conv.is_owned = false;
35879 LDKStr val_conv = str_ref_to_owned_c(val);
35880 LightningError_set_err(&this_ptr_conv, val_conv);
35883 uint64_t __attribute__((export_name("TS_LightningError_get_action"))) TS_LightningError_get_action(uint64_t this_ptr) {
35884 LDKLightningError this_ptr_conv;
35885 this_ptr_conv.inner = untag_ptr(this_ptr);
35886 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35888 this_ptr_conv.is_owned = false;
35889 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
35890 *ret_copy = LightningError_get_action(&this_ptr_conv);
35891 uint64_t ret_ref = tag_ptr(ret_copy, true);
35895 void __attribute__((export_name("TS_LightningError_set_action"))) TS_LightningError_set_action(uint64_t this_ptr, uint64_t val) {
35896 LDKLightningError this_ptr_conv;
35897 this_ptr_conv.inner = untag_ptr(this_ptr);
35898 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35900 this_ptr_conv.is_owned = false;
35901 void* val_ptr = untag_ptr(val);
35902 CHECK_ACCESS(val_ptr);
35903 LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
35904 val_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(val));
35905 LightningError_set_action(&this_ptr_conv, val_conv);
35908 uint64_t __attribute__((export_name("TS_LightningError_new"))) TS_LightningError_new(jstring err_arg, uint64_t action_arg) {
35909 LDKStr err_arg_conv = str_ref_to_owned_c(err_arg);
35910 void* action_arg_ptr = untag_ptr(action_arg);
35911 CHECK_ACCESS(action_arg_ptr);
35912 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(action_arg_ptr);
35913 action_arg_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action_arg));
35914 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
35915 uint64_t ret_ref = 0;
35916 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35917 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35921 static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
35922 LDKLightningError ret_var = LightningError_clone(arg);
35923 uint64_t ret_ref = 0;
35924 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35925 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35928 int64_t __attribute__((export_name("TS_LightningError_clone_ptr"))) TS_LightningError_clone_ptr(uint64_t arg) {
35929 LDKLightningError arg_conv;
35930 arg_conv.inner = untag_ptr(arg);
35931 arg_conv.is_owned = ptr_is_owned(arg);
35932 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35933 arg_conv.is_owned = false;
35934 int64_t ret_conv = LightningError_clone_ptr(&arg_conv);
35938 uint64_t __attribute__((export_name("TS_LightningError_clone"))) TS_LightningError_clone(uint64_t orig) {
35939 LDKLightningError orig_conv;
35940 orig_conv.inner = untag_ptr(orig);
35941 orig_conv.is_owned = ptr_is_owned(orig);
35942 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35943 orig_conv.is_owned = false;
35944 LDKLightningError ret_var = LightningError_clone(&orig_conv);
35945 uint64_t ret_ref = 0;
35946 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35947 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35951 void __attribute__((export_name("TS_CommitmentUpdate_free"))) TS_CommitmentUpdate_free(uint64_t this_obj) {
35952 LDKCommitmentUpdate this_obj_conv;
35953 this_obj_conv.inner = untag_ptr(this_obj);
35954 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35956 CommitmentUpdate_free(this_obj_conv);
35959 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_add_htlcs"))) TS_CommitmentUpdate_get_update_add_htlcs(uint64_t this_ptr) {
35960 LDKCommitmentUpdate this_ptr_conv;
35961 this_ptr_conv.inner = untag_ptr(this_ptr);
35962 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35964 this_ptr_conv.is_owned = false;
35965 LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
35966 uint64_tArray ret_arr = NULL;
35967 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
35968 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
35969 for (size_t p = 0; p < ret_var.datalen; p++) {
35970 LDKUpdateAddHTLC ret_conv_15_var = ret_var.data[p];
35971 uint64_t ret_conv_15_ref = 0;
35972 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
35973 ret_conv_15_ref = tag_ptr(ret_conv_15_var.inner, ret_conv_15_var.is_owned);
35974 ret_arr_ptr[p] = ret_conv_15_ref;
35977 FREE(ret_var.data);
35981 void __attribute__((export_name("TS_CommitmentUpdate_set_update_add_htlcs"))) TS_CommitmentUpdate_set_update_add_htlcs(uint64_t this_ptr, uint64_tArray val) {
35982 LDKCommitmentUpdate this_ptr_conv;
35983 this_ptr_conv.inner = untag_ptr(this_ptr);
35984 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35986 this_ptr_conv.is_owned = false;
35987 LDKCVec_UpdateAddHTLCZ val_constr;
35988 val_constr.datalen = val->arr_len;
35989 if (val_constr.datalen > 0)
35990 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
35992 val_constr.data = NULL;
35993 uint64_t* val_vals = val->elems;
35994 for (size_t p = 0; p < val_constr.datalen; p++) {
35995 uint64_t val_conv_15 = val_vals[p];
35996 LDKUpdateAddHTLC val_conv_15_conv;
35997 val_conv_15_conv.inner = untag_ptr(val_conv_15);
35998 val_conv_15_conv.is_owned = ptr_is_owned(val_conv_15);
35999 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
36000 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
36001 val_constr.data[p] = val_conv_15_conv;
36004 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
36007 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fulfill_htlcs"))) TS_CommitmentUpdate_get_update_fulfill_htlcs(uint64_t this_ptr) {
36008 LDKCommitmentUpdate this_ptr_conv;
36009 this_ptr_conv.inner = untag_ptr(this_ptr);
36010 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36012 this_ptr_conv.is_owned = false;
36013 LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
36014 uint64_tArray ret_arr = NULL;
36015 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
36016 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
36017 for (size_t t = 0; t < ret_var.datalen; t++) {
36018 LDKUpdateFulfillHTLC ret_conv_19_var = ret_var.data[t];
36019 uint64_t ret_conv_19_ref = 0;
36020 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
36021 ret_conv_19_ref = tag_ptr(ret_conv_19_var.inner, ret_conv_19_var.is_owned);
36022 ret_arr_ptr[t] = ret_conv_19_ref;
36025 FREE(ret_var.data);
36029 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fulfill_htlcs"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint64_t this_ptr, uint64_tArray val) {
36030 LDKCommitmentUpdate this_ptr_conv;
36031 this_ptr_conv.inner = untag_ptr(this_ptr);
36032 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36033 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36034 this_ptr_conv.is_owned = false;
36035 LDKCVec_UpdateFulfillHTLCZ val_constr;
36036 val_constr.datalen = val->arr_len;
36037 if (val_constr.datalen > 0)
36038 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
36040 val_constr.data = NULL;
36041 uint64_t* val_vals = val->elems;
36042 for (size_t t = 0; t < val_constr.datalen; t++) {
36043 uint64_t val_conv_19 = val_vals[t];
36044 LDKUpdateFulfillHTLC val_conv_19_conv;
36045 val_conv_19_conv.inner = untag_ptr(val_conv_19);
36046 val_conv_19_conv.is_owned = ptr_is_owned(val_conv_19);
36047 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
36048 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
36049 val_constr.data[t] = val_conv_19_conv;
36052 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
36055 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_htlcs"))) TS_CommitmentUpdate_get_update_fail_htlcs(uint64_t this_ptr) {
36056 LDKCommitmentUpdate this_ptr_conv;
36057 this_ptr_conv.inner = untag_ptr(this_ptr);
36058 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36060 this_ptr_conv.is_owned = false;
36061 LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
36062 uint64_tArray ret_arr = NULL;
36063 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
36064 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
36065 for (size_t q = 0; q < ret_var.datalen; q++) {
36066 LDKUpdateFailHTLC ret_conv_16_var = ret_var.data[q];
36067 uint64_t ret_conv_16_ref = 0;
36068 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
36069 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
36070 ret_arr_ptr[q] = ret_conv_16_ref;
36073 FREE(ret_var.data);
36077 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_htlcs"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint64_t this_ptr, uint64_tArray val) {
36078 LDKCommitmentUpdate this_ptr_conv;
36079 this_ptr_conv.inner = untag_ptr(this_ptr);
36080 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36081 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36082 this_ptr_conv.is_owned = false;
36083 LDKCVec_UpdateFailHTLCZ val_constr;
36084 val_constr.datalen = val->arr_len;
36085 if (val_constr.datalen > 0)
36086 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
36088 val_constr.data = NULL;
36089 uint64_t* val_vals = val->elems;
36090 for (size_t q = 0; q < val_constr.datalen; q++) {
36091 uint64_t val_conv_16 = val_vals[q];
36092 LDKUpdateFailHTLC val_conv_16_conv;
36093 val_conv_16_conv.inner = untag_ptr(val_conv_16);
36094 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
36095 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
36096 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
36097 val_constr.data[q] = val_conv_16_conv;
36100 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
36103 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_get_update_fail_malformed_htlcs(uint64_t this_ptr) {
36104 LDKCommitmentUpdate this_ptr_conv;
36105 this_ptr_conv.inner = untag_ptr(this_ptr);
36106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36108 this_ptr_conv.is_owned = false;
36109 LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
36110 uint64_tArray ret_arr = NULL;
36111 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
36112 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
36113 for (size_t z = 0; z < ret_var.datalen; z++) {
36114 LDKUpdateFailMalformedHTLC ret_conv_25_var = ret_var.data[z];
36115 uint64_t ret_conv_25_ref = 0;
36116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
36117 ret_conv_25_ref = tag_ptr(ret_conv_25_var.inner, ret_conv_25_var.is_owned);
36118 ret_arr_ptr[z] = ret_conv_25_ref;
36121 FREE(ret_var.data);
36125 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) {
36126 LDKCommitmentUpdate this_ptr_conv;
36127 this_ptr_conv.inner = untag_ptr(this_ptr);
36128 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36130 this_ptr_conv.is_owned = false;
36131 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
36132 val_constr.datalen = val->arr_len;
36133 if (val_constr.datalen > 0)
36134 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
36136 val_constr.data = NULL;
36137 uint64_t* val_vals = val->elems;
36138 for (size_t z = 0; z < val_constr.datalen; z++) {
36139 uint64_t val_conv_25 = val_vals[z];
36140 LDKUpdateFailMalformedHTLC val_conv_25_conv;
36141 val_conv_25_conv.inner = untag_ptr(val_conv_25);
36142 val_conv_25_conv.is_owned = ptr_is_owned(val_conv_25);
36143 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
36144 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
36145 val_constr.data[z] = val_conv_25_conv;
36148 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
36151 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_update_fee"))) TS_CommitmentUpdate_get_update_fee(uint64_t this_ptr) {
36152 LDKCommitmentUpdate this_ptr_conv;
36153 this_ptr_conv.inner = untag_ptr(this_ptr);
36154 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36156 this_ptr_conv.is_owned = false;
36157 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
36158 uint64_t ret_ref = 0;
36159 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36160 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36164 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fee"))) TS_CommitmentUpdate_set_update_fee(uint64_t this_ptr, uint64_t val) {
36165 LDKCommitmentUpdate this_ptr_conv;
36166 this_ptr_conv.inner = untag_ptr(this_ptr);
36167 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36169 this_ptr_conv.is_owned = false;
36170 LDKUpdateFee val_conv;
36171 val_conv.inner = untag_ptr(val);
36172 val_conv.is_owned = ptr_is_owned(val);
36173 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36174 val_conv = UpdateFee_clone(&val_conv);
36175 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
36178 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_commitment_signed"))) TS_CommitmentUpdate_get_commitment_signed(uint64_t this_ptr) {
36179 LDKCommitmentUpdate this_ptr_conv;
36180 this_ptr_conv.inner = untag_ptr(this_ptr);
36181 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36182 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36183 this_ptr_conv.is_owned = false;
36184 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
36185 uint64_t ret_ref = 0;
36186 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36187 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36191 void __attribute__((export_name("TS_CommitmentUpdate_set_commitment_signed"))) TS_CommitmentUpdate_set_commitment_signed(uint64_t this_ptr, uint64_t val) {
36192 LDKCommitmentUpdate this_ptr_conv;
36193 this_ptr_conv.inner = untag_ptr(this_ptr);
36194 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36196 this_ptr_conv.is_owned = false;
36197 LDKCommitmentSigned val_conv;
36198 val_conv.inner = untag_ptr(val);
36199 val_conv.is_owned = ptr_is_owned(val);
36200 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36201 val_conv = CommitmentSigned_clone(&val_conv);
36202 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
36205 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) {
36206 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
36207 update_add_htlcs_arg_constr.datalen = update_add_htlcs_arg->arr_len;
36208 if (update_add_htlcs_arg_constr.datalen > 0)
36209 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
36211 update_add_htlcs_arg_constr.data = NULL;
36212 uint64_t* update_add_htlcs_arg_vals = update_add_htlcs_arg->elems;
36213 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
36214 uint64_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
36215 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
36216 update_add_htlcs_arg_conv_15_conv.inner = untag_ptr(update_add_htlcs_arg_conv_15);
36217 update_add_htlcs_arg_conv_15_conv.is_owned = ptr_is_owned(update_add_htlcs_arg_conv_15);
36218 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
36219 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
36220 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
36222 FREE(update_add_htlcs_arg);
36223 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
36224 update_fulfill_htlcs_arg_constr.datalen = update_fulfill_htlcs_arg->arr_len;
36225 if (update_fulfill_htlcs_arg_constr.datalen > 0)
36226 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
36228 update_fulfill_htlcs_arg_constr.data = NULL;
36229 uint64_t* update_fulfill_htlcs_arg_vals = update_fulfill_htlcs_arg->elems;
36230 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
36231 uint64_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
36232 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
36233 update_fulfill_htlcs_arg_conv_19_conv.inner = untag_ptr(update_fulfill_htlcs_arg_conv_19);
36234 update_fulfill_htlcs_arg_conv_19_conv.is_owned = ptr_is_owned(update_fulfill_htlcs_arg_conv_19);
36235 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
36236 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
36237 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
36239 FREE(update_fulfill_htlcs_arg);
36240 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
36241 update_fail_htlcs_arg_constr.datalen = update_fail_htlcs_arg->arr_len;
36242 if (update_fail_htlcs_arg_constr.datalen > 0)
36243 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
36245 update_fail_htlcs_arg_constr.data = NULL;
36246 uint64_t* update_fail_htlcs_arg_vals = update_fail_htlcs_arg->elems;
36247 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
36248 uint64_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
36249 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
36250 update_fail_htlcs_arg_conv_16_conv.inner = untag_ptr(update_fail_htlcs_arg_conv_16);
36251 update_fail_htlcs_arg_conv_16_conv.is_owned = ptr_is_owned(update_fail_htlcs_arg_conv_16);
36252 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
36253 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
36254 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
36256 FREE(update_fail_htlcs_arg);
36257 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
36258 update_fail_malformed_htlcs_arg_constr.datalen = update_fail_malformed_htlcs_arg->arr_len;
36259 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
36260 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
36262 update_fail_malformed_htlcs_arg_constr.data = NULL;
36263 uint64_t* update_fail_malformed_htlcs_arg_vals = update_fail_malformed_htlcs_arg->elems;
36264 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
36265 uint64_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
36266 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
36267 update_fail_malformed_htlcs_arg_conv_25_conv.inner = untag_ptr(update_fail_malformed_htlcs_arg_conv_25);
36268 update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = ptr_is_owned(update_fail_malformed_htlcs_arg_conv_25);
36269 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
36270 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
36271 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
36273 FREE(update_fail_malformed_htlcs_arg);
36274 LDKUpdateFee update_fee_arg_conv;
36275 update_fee_arg_conv.inner = untag_ptr(update_fee_arg);
36276 update_fee_arg_conv.is_owned = ptr_is_owned(update_fee_arg);
36277 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
36278 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
36279 LDKCommitmentSigned commitment_signed_arg_conv;
36280 commitment_signed_arg_conv.inner = untag_ptr(commitment_signed_arg);
36281 commitment_signed_arg_conv.is_owned = ptr_is_owned(commitment_signed_arg);
36282 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
36283 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
36284 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);
36285 uint64_t ret_ref = 0;
36286 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36287 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36291 static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
36292 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
36293 uint64_t ret_ref = 0;
36294 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36295 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36298 int64_t __attribute__((export_name("TS_CommitmentUpdate_clone_ptr"))) TS_CommitmentUpdate_clone_ptr(uint64_t arg) {
36299 LDKCommitmentUpdate arg_conv;
36300 arg_conv.inner = untag_ptr(arg);
36301 arg_conv.is_owned = ptr_is_owned(arg);
36302 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36303 arg_conv.is_owned = false;
36304 int64_t ret_conv = CommitmentUpdate_clone_ptr(&arg_conv);
36308 uint64_t __attribute__((export_name("TS_CommitmentUpdate_clone"))) TS_CommitmentUpdate_clone(uint64_t orig) {
36309 LDKCommitmentUpdate orig_conv;
36310 orig_conv.inner = untag_ptr(orig);
36311 orig_conv.is_owned = ptr_is_owned(orig);
36312 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36313 orig_conv.is_owned = false;
36314 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
36315 uint64_t ret_ref = 0;
36316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36321 jboolean __attribute__((export_name("TS_CommitmentUpdate_eq"))) TS_CommitmentUpdate_eq(uint64_t a, uint64_t b) {
36322 LDKCommitmentUpdate a_conv;
36323 a_conv.inner = untag_ptr(a);
36324 a_conv.is_owned = ptr_is_owned(a);
36325 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36326 a_conv.is_owned = false;
36327 LDKCommitmentUpdate b_conv;
36328 b_conv.inner = untag_ptr(b);
36329 b_conv.is_owned = ptr_is_owned(b);
36330 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36331 b_conv.is_owned = false;
36332 jboolean ret_conv = CommitmentUpdate_eq(&a_conv, &b_conv);
36336 void __attribute__((export_name("TS_ChannelMessageHandler_free"))) TS_ChannelMessageHandler_free(uint64_t this_ptr) {
36337 if (!ptr_is_owned(this_ptr)) return;
36338 void* this_ptr_ptr = untag_ptr(this_ptr);
36339 CHECK_ACCESS(this_ptr_ptr);
36340 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(this_ptr_ptr);
36341 FREE(untag_ptr(this_ptr));
36342 ChannelMessageHandler_free(this_ptr_conv);
36345 void __attribute__((export_name("TS_RoutingMessageHandler_free"))) TS_RoutingMessageHandler_free(uint64_t this_ptr) {
36346 if (!ptr_is_owned(this_ptr)) return;
36347 void* this_ptr_ptr = untag_ptr(this_ptr);
36348 CHECK_ACCESS(this_ptr_ptr);
36349 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(this_ptr_ptr);
36350 FREE(untag_ptr(this_ptr));
36351 RoutingMessageHandler_free(this_ptr_conv);
36354 void __attribute__((export_name("TS_OnionMessageHandler_free"))) TS_OnionMessageHandler_free(uint64_t this_ptr) {
36355 if (!ptr_is_owned(this_ptr)) return;
36356 void* this_ptr_ptr = untag_ptr(this_ptr);
36357 CHECK_ACCESS(this_ptr_ptr);
36358 LDKOnionMessageHandler this_ptr_conv = *(LDKOnionMessageHandler*)(this_ptr_ptr);
36359 FREE(untag_ptr(this_ptr));
36360 OnionMessageHandler_free(this_ptr_conv);
36363 int8_tArray __attribute__((export_name("TS_AcceptChannel_write"))) TS_AcceptChannel_write(uint64_t obj) {
36364 LDKAcceptChannel obj_conv;
36365 obj_conv.inner = untag_ptr(obj);
36366 obj_conv.is_owned = ptr_is_owned(obj);
36367 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36368 obj_conv.is_owned = false;
36369 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
36370 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36371 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36372 CVec_u8Z_free(ret_var);
36376 uint64_t __attribute__((export_name("TS_AcceptChannel_read"))) TS_AcceptChannel_read(int8_tArray ser) {
36377 LDKu8slice ser_ref;
36378 ser_ref.datalen = ser->arr_len;
36379 ser_ref.data = ser->elems;
36380 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
36381 *ret_conv = AcceptChannel_read(ser_ref);
36383 return tag_ptr(ret_conv, true);
36386 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_write"))) TS_AnnouncementSignatures_write(uint64_t obj) {
36387 LDKAnnouncementSignatures obj_conv;
36388 obj_conv.inner = untag_ptr(obj);
36389 obj_conv.is_owned = ptr_is_owned(obj);
36390 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36391 obj_conv.is_owned = false;
36392 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
36393 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36394 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36395 CVec_u8Z_free(ret_var);
36399 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_read"))) TS_AnnouncementSignatures_read(int8_tArray ser) {
36400 LDKu8slice ser_ref;
36401 ser_ref.datalen = ser->arr_len;
36402 ser_ref.data = ser->elems;
36403 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
36404 *ret_conv = AnnouncementSignatures_read(ser_ref);
36406 return tag_ptr(ret_conv, true);
36409 int8_tArray __attribute__((export_name("TS_ChannelReestablish_write"))) TS_ChannelReestablish_write(uint64_t obj) {
36410 LDKChannelReestablish obj_conv;
36411 obj_conv.inner = untag_ptr(obj);
36412 obj_conv.is_owned = ptr_is_owned(obj);
36413 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36414 obj_conv.is_owned = false;
36415 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
36416 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36417 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36418 CVec_u8Z_free(ret_var);
36422 uint64_t __attribute__((export_name("TS_ChannelReestablish_read"))) TS_ChannelReestablish_read(int8_tArray ser) {
36423 LDKu8slice ser_ref;
36424 ser_ref.datalen = ser->arr_len;
36425 ser_ref.data = ser->elems;
36426 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
36427 *ret_conv = ChannelReestablish_read(ser_ref);
36429 return tag_ptr(ret_conv, true);
36432 int8_tArray __attribute__((export_name("TS_ClosingSigned_write"))) TS_ClosingSigned_write(uint64_t obj) {
36433 LDKClosingSigned obj_conv;
36434 obj_conv.inner = untag_ptr(obj);
36435 obj_conv.is_owned = ptr_is_owned(obj);
36436 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36437 obj_conv.is_owned = false;
36438 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
36439 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36440 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36441 CVec_u8Z_free(ret_var);
36445 uint64_t __attribute__((export_name("TS_ClosingSigned_read"))) TS_ClosingSigned_read(int8_tArray ser) {
36446 LDKu8slice ser_ref;
36447 ser_ref.datalen = ser->arr_len;
36448 ser_ref.data = ser->elems;
36449 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
36450 *ret_conv = ClosingSigned_read(ser_ref);
36452 return tag_ptr(ret_conv, true);
36455 int8_tArray __attribute__((export_name("TS_ClosingSignedFeeRange_write"))) TS_ClosingSignedFeeRange_write(uint64_t obj) {
36456 LDKClosingSignedFeeRange obj_conv;
36457 obj_conv.inner = untag_ptr(obj);
36458 obj_conv.is_owned = ptr_is_owned(obj);
36459 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36460 obj_conv.is_owned = false;
36461 LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
36462 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36463 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36464 CVec_u8Z_free(ret_var);
36468 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_read"))) TS_ClosingSignedFeeRange_read(int8_tArray ser) {
36469 LDKu8slice ser_ref;
36470 ser_ref.datalen = ser->arr_len;
36471 ser_ref.data = ser->elems;
36472 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
36473 *ret_conv = ClosingSignedFeeRange_read(ser_ref);
36475 return tag_ptr(ret_conv, true);
36478 int8_tArray __attribute__((export_name("TS_CommitmentSigned_write"))) TS_CommitmentSigned_write(uint64_t obj) {
36479 LDKCommitmentSigned obj_conv;
36480 obj_conv.inner = untag_ptr(obj);
36481 obj_conv.is_owned = ptr_is_owned(obj);
36482 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36483 obj_conv.is_owned = false;
36484 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
36485 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36486 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36487 CVec_u8Z_free(ret_var);
36491 uint64_t __attribute__((export_name("TS_CommitmentSigned_read"))) TS_CommitmentSigned_read(int8_tArray ser) {
36492 LDKu8slice ser_ref;
36493 ser_ref.datalen = ser->arr_len;
36494 ser_ref.data = ser->elems;
36495 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
36496 *ret_conv = CommitmentSigned_read(ser_ref);
36498 return tag_ptr(ret_conv, true);
36501 int8_tArray __attribute__((export_name("TS_FundingCreated_write"))) TS_FundingCreated_write(uint64_t obj) {
36502 LDKFundingCreated obj_conv;
36503 obj_conv.inner = untag_ptr(obj);
36504 obj_conv.is_owned = ptr_is_owned(obj);
36505 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36506 obj_conv.is_owned = false;
36507 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
36508 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36509 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36510 CVec_u8Z_free(ret_var);
36514 uint64_t __attribute__((export_name("TS_FundingCreated_read"))) TS_FundingCreated_read(int8_tArray ser) {
36515 LDKu8slice ser_ref;
36516 ser_ref.datalen = ser->arr_len;
36517 ser_ref.data = ser->elems;
36518 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
36519 *ret_conv = FundingCreated_read(ser_ref);
36521 return tag_ptr(ret_conv, true);
36524 int8_tArray __attribute__((export_name("TS_FundingSigned_write"))) TS_FundingSigned_write(uint64_t obj) {
36525 LDKFundingSigned obj_conv;
36526 obj_conv.inner = untag_ptr(obj);
36527 obj_conv.is_owned = ptr_is_owned(obj);
36528 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36529 obj_conv.is_owned = false;
36530 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
36531 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36532 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36533 CVec_u8Z_free(ret_var);
36537 uint64_t __attribute__((export_name("TS_FundingSigned_read"))) TS_FundingSigned_read(int8_tArray ser) {
36538 LDKu8slice ser_ref;
36539 ser_ref.datalen = ser->arr_len;
36540 ser_ref.data = ser->elems;
36541 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
36542 *ret_conv = FundingSigned_read(ser_ref);
36544 return tag_ptr(ret_conv, true);
36547 int8_tArray __attribute__((export_name("TS_ChannelReady_write"))) TS_ChannelReady_write(uint64_t obj) {
36548 LDKChannelReady obj_conv;
36549 obj_conv.inner = untag_ptr(obj);
36550 obj_conv.is_owned = ptr_is_owned(obj);
36551 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36552 obj_conv.is_owned = false;
36553 LDKCVec_u8Z ret_var = ChannelReady_write(&obj_conv);
36554 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36555 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36556 CVec_u8Z_free(ret_var);
36560 uint64_t __attribute__((export_name("TS_ChannelReady_read"))) TS_ChannelReady_read(int8_tArray ser) {
36561 LDKu8slice ser_ref;
36562 ser_ref.datalen = ser->arr_len;
36563 ser_ref.data = ser->elems;
36564 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
36565 *ret_conv = ChannelReady_read(ser_ref);
36567 return tag_ptr(ret_conv, true);
36570 int8_tArray __attribute__((export_name("TS_Init_write"))) TS_Init_write(uint64_t obj) {
36572 obj_conv.inner = untag_ptr(obj);
36573 obj_conv.is_owned = ptr_is_owned(obj);
36574 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36575 obj_conv.is_owned = false;
36576 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
36577 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36578 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36579 CVec_u8Z_free(ret_var);
36583 uint64_t __attribute__((export_name("TS_Init_read"))) TS_Init_read(int8_tArray ser) {
36584 LDKu8slice ser_ref;
36585 ser_ref.datalen = ser->arr_len;
36586 ser_ref.data = ser->elems;
36587 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
36588 *ret_conv = Init_read(ser_ref);
36590 return tag_ptr(ret_conv, true);
36593 int8_tArray __attribute__((export_name("TS_OpenChannel_write"))) TS_OpenChannel_write(uint64_t obj) {
36594 LDKOpenChannel obj_conv;
36595 obj_conv.inner = untag_ptr(obj);
36596 obj_conv.is_owned = ptr_is_owned(obj);
36597 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36598 obj_conv.is_owned = false;
36599 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
36600 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36601 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36602 CVec_u8Z_free(ret_var);
36606 uint64_t __attribute__((export_name("TS_OpenChannel_read"))) TS_OpenChannel_read(int8_tArray ser) {
36607 LDKu8slice ser_ref;
36608 ser_ref.datalen = ser->arr_len;
36609 ser_ref.data = ser->elems;
36610 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
36611 *ret_conv = OpenChannel_read(ser_ref);
36613 return tag_ptr(ret_conv, true);
36616 int8_tArray __attribute__((export_name("TS_RevokeAndACK_write"))) TS_RevokeAndACK_write(uint64_t obj) {
36617 LDKRevokeAndACK obj_conv;
36618 obj_conv.inner = untag_ptr(obj);
36619 obj_conv.is_owned = ptr_is_owned(obj);
36620 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36621 obj_conv.is_owned = false;
36622 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
36623 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36624 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36625 CVec_u8Z_free(ret_var);
36629 uint64_t __attribute__((export_name("TS_RevokeAndACK_read"))) TS_RevokeAndACK_read(int8_tArray ser) {
36630 LDKu8slice ser_ref;
36631 ser_ref.datalen = ser->arr_len;
36632 ser_ref.data = ser->elems;
36633 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
36634 *ret_conv = RevokeAndACK_read(ser_ref);
36636 return tag_ptr(ret_conv, true);
36639 int8_tArray __attribute__((export_name("TS_Shutdown_write"))) TS_Shutdown_write(uint64_t obj) {
36640 LDKShutdown obj_conv;
36641 obj_conv.inner = untag_ptr(obj);
36642 obj_conv.is_owned = ptr_is_owned(obj);
36643 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36644 obj_conv.is_owned = false;
36645 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
36646 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36647 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36648 CVec_u8Z_free(ret_var);
36652 uint64_t __attribute__((export_name("TS_Shutdown_read"))) TS_Shutdown_read(int8_tArray ser) {
36653 LDKu8slice ser_ref;
36654 ser_ref.datalen = ser->arr_len;
36655 ser_ref.data = ser->elems;
36656 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
36657 *ret_conv = Shutdown_read(ser_ref);
36659 return tag_ptr(ret_conv, true);
36662 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_write"))) TS_UpdateFailHTLC_write(uint64_t obj) {
36663 LDKUpdateFailHTLC obj_conv;
36664 obj_conv.inner = untag_ptr(obj);
36665 obj_conv.is_owned = ptr_is_owned(obj);
36666 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36667 obj_conv.is_owned = false;
36668 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
36669 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36670 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36671 CVec_u8Z_free(ret_var);
36675 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_read"))) TS_UpdateFailHTLC_read(int8_tArray ser) {
36676 LDKu8slice ser_ref;
36677 ser_ref.datalen = ser->arr_len;
36678 ser_ref.data = ser->elems;
36679 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
36680 *ret_conv = UpdateFailHTLC_read(ser_ref);
36682 return tag_ptr(ret_conv, true);
36685 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_write"))) TS_UpdateFailMalformedHTLC_write(uint64_t obj) {
36686 LDKUpdateFailMalformedHTLC obj_conv;
36687 obj_conv.inner = untag_ptr(obj);
36688 obj_conv.is_owned = ptr_is_owned(obj);
36689 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36690 obj_conv.is_owned = false;
36691 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
36692 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36693 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36694 CVec_u8Z_free(ret_var);
36698 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_read"))) TS_UpdateFailMalformedHTLC_read(int8_tArray ser) {
36699 LDKu8slice ser_ref;
36700 ser_ref.datalen = ser->arr_len;
36701 ser_ref.data = ser->elems;
36702 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
36703 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
36705 return tag_ptr(ret_conv, true);
36708 int8_tArray __attribute__((export_name("TS_UpdateFee_write"))) TS_UpdateFee_write(uint64_t obj) {
36709 LDKUpdateFee obj_conv;
36710 obj_conv.inner = untag_ptr(obj);
36711 obj_conv.is_owned = ptr_is_owned(obj);
36712 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36713 obj_conv.is_owned = false;
36714 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
36715 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36716 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36717 CVec_u8Z_free(ret_var);
36721 uint64_t __attribute__((export_name("TS_UpdateFee_read"))) TS_UpdateFee_read(int8_tArray ser) {
36722 LDKu8slice ser_ref;
36723 ser_ref.datalen = ser->arr_len;
36724 ser_ref.data = ser->elems;
36725 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
36726 *ret_conv = UpdateFee_read(ser_ref);
36728 return tag_ptr(ret_conv, true);
36731 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_write"))) TS_UpdateFulfillHTLC_write(uint64_t obj) {
36732 LDKUpdateFulfillHTLC obj_conv;
36733 obj_conv.inner = untag_ptr(obj);
36734 obj_conv.is_owned = ptr_is_owned(obj);
36735 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36736 obj_conv.is_owned = false;
36737 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
36738 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36739 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36740 CVec_u8Z_free(ret_var);
36744 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_read"))) TS_UpdateFulfillHTLC_read(int8_tArray ser) {
36745 LDKu8slice ser_ref;
36746 ser_ref.datalen = ser->arr_len;
36747 ser_ref.data = ser->elems;
36748 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
36749 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
36751 return tag_ptr(ret_conv, true);
36754 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_write"))) TS_UpdateAddHTLC_write(uint64_t obj) {
36755 LDKUpdateAddHTLC obj_conv;
36756 obj_conv.inner = untag_ptr(obj);
36757 obj_conv.is_owned = ptr_is_owned(obj);
36758 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36759 obj_conv.is_owned = false;
36760 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
36761 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36762 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36763 CVec_u8Z_free(ret_var);
36767 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_read"))) TS_UpdateAddHTLC_read(int8_tArray ser) {
36768 LDKu8slice ser_ref;
36769 ser_ref.datalen = ser->arr_len;
36770 ser_ref.data = ser->elems;
36771 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
36772 *ret_conv = UpdateAddHTLC_read(ser_ref);
36774 return tag_ptr(ret_conv, true);
36777 uint64_t __attribute__((export_name("TS_OnionMessage_read"))) TS_OnionMessage_read(int8_tArray ser) {
36778 LDKu8slice ser_ref;
36779 ser_ref.datalen = ser->arr_len;
36780 ser_ref.data = ser->elems;
36781 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
36782 *ret_conv = OnionMessage_read(ser_ref);
36784 return tag_ptr(ret_conv, true);
36787 int8_tArray __attribute__((export_name("TS_OnionMessage_write"))) TS_OnionMessage_write(uint64_t obj) {
36788 LDKOnionMessage obj_conv;
36789 obj_conv.inner = untag_ptr(obj);
36790 obj_conv.is_owned = ptr_is_owned(obj);
36791 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36792 obj_conv.is_owned = false;
36793 LDKCVec_u8Z ret_var = OnionMessage_write(&obj_conv);
36794 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36795 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36796 CVec_u8Z_free(ret_var);
36800 int8_tArray __attribute__((export_name("TS_Ping_write"))) TS_Ping_write(uint64_t obj) {
36802 obj_conv.inner = untag_ptr(obj);
36803 obj_conv.is_owned = ptr_is_owned(obj);
36804 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36805 obj_conv.is_owned = false;
36806 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
36807 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36808 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36809 CVec_u8Z_free(ret_var);
36813 uint64_t __attribute__((export_name("TS_Ping_read"))) TS_Ping_read(int8_tArray ser) {
36814 LDKu8slice ser_ref;
36815 ser_ref.datalen = ser->arr_len;
36816 ser_ref.data = ser->elems;
36817 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
36818 *ret_conv = Ping_read(ser_ref);
36820 return tag_ptr(ret_conv, true);
36823 int8_tArray __attribute__((export_name("TS_Pong_write"))) TS_Pong_write(uint64_t obj) {
36825 obj_conv.inner = untag_ptr(obj);
36826 obj_conv.is_owned = ptr_is_owned(obj);
36827 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36828 obj_conv.is_owned = false;
36829 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
36830 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36831 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36832 CVec_u8Z_free(ret_var);
36836 uint64_t __attribute__((export_name("TS_Pong_read"))) TS_Pong_read(int8_tArray ser) {
36837 LDKu8slice ser_ref;
36838 ser_ref.datalen = ser->arr_len;
36839 ser_ref.data = ser->elems;
36840 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
36841 *ret_conv = Pong_read(ser_ref);
36843 return tag_ptr(ret_conv, true);
36846 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_write"))) TS_UnsignedChannelAnnouncement_write(uint64_t obj) {
36847 LDKUnsignedChannelAnnouncement obj_conv;
36848 obj_conv.inner = untag_ptr(obj);
36849 obj_conv.is_owned = ptr_is_owned(obj);
36850 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36851 obj_conv.is_owned = false;
36852 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
36853 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36854 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36855 CVec_u8Z_free(ret_var);
36859 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_read"))) TS_UnsignedChannelAnnouncement_read(int8_tArray ser) {
36860 LDKu8slice ser_ref;
36861 ser_ref.datalen = ser->arr_len;
36862 ser_ref.data = ser->elems;
36863 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
36864 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
36866 return tag_ptr(ret_conv, true);
36869 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_write"))) TS_ChannelAnnouncement_write(uint64_t obj) {
36870 LDKChannelAnnouncement obj_conv;
36871 obj_conv.inner = untag_ptr(obj);
36872 obj_conv.is_owned = ptr_is_owned(obj);
36873 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36874 obj_conv.is_owned = false;
36875 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
36876 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36877 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36878 CVec_u8Z_free(ret_var);
36882 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_read"))) TS_ChannelAnnouncement_read(int8_tArray ser) {
36883 LDKu8slice ser_ref;
36884 ser_ref.datalen = ser->arr_len;
36885 ser_ref.data = ser->elems;
36886 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
36887 *ret_conv = ChannelAnnouncement_read(ser_ref);
36889 return tag_ptr(ret_conv, true);
36892 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_write"))) TS_UnsignedChannelUpdate_write(uint64_t obj) {
36893 LDKUnsignedChannelUpdate obj_conv;
36894 obj_conv.inner = untag_ptr(obj);
36895 obj_conv.is_owned = ptr_is_owned(obj);
36896 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36897 obj_conv.is_owned = false;
36898 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
36899 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36900 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36901 CVec_u8Z_free(ret_var);
36905 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_read"))) TS_UnsignedChannelUpdate_read(int8_tArray ser) {
36906 LDKu8slice ser_ref;
36907 ser_ref.datalen = ser->arr_len;
36908 ser_ref.data = ser->elems;
36909 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
36910 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
36912 return tag_ptr(ret_conv, true);
36915 int8_tArray __attribute__((export_name("TS_ChannelUpdate_write"))) TS_ChannelUpdate_write(uint64_t obj) {
36916 LDKChannelUpdate obj_conv;
36917 obj_conv.inner = untag_ptr(obj);
36918 obj_conv.is_owned = ptr_is_owned(obj);
36919 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36920 obj_conv.is_owned = false;
36921 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
36922 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36923 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36924 CVec_u8Z_free(ret_var);
36928 uint64_t __attribute__((export_name("TS_ChannelUpdate_read"))) TS_ChannelUpdate_read(int8_tArray ser) {
36929 LDKu8slice ser_ref;
36930 ser_ref.datalen = ser->arr_len;
36931 ser_ref.data = ser->elems;
36932 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
36933 *ret_conv = ChannelUpdate_read(ser_ref);
36935 return tag_ptr(ret_conv, true);
36938 int8_tArray __attribute__((export_name("TS_ErrorMessage_write"))) TS_ErrorMessage_write(uint64_t obj) {
36939 LDKErrorMessage obj_conv;
36940 obj_conv.inner = untag_ptr(obj);
36941 obj_conv.is_owned = ptr_is_owned(obj);
36942 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36943 obj_conv.is_owned = false;
36944 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
36945 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36946 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36947 CVec_u8Z_free(ret_var);
36951 uint64_t __attribute__((export_name("TS_ErrorMessage_read"))) TS_ErrorMessage_read(int8_tArray ser) {
36952 LDKu8slice ser_ref;
36953 ser_ref.datalen = ser->arr_len;
36954 ser_ref.data = ser->elems;
36955 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
36956 *ret_conv = ErrorMessage_read(ser_ref);
36958 return tag_ptr(ret_conv, true);
36961 int8_tArray __attribute__((export_name("TS_WarningMessage_write"))) TS_WarningMessage_write(uint64_t obj) {
36962 LDKWarningMessage obj_conv;
36963 obj_conv.inner = untag_ptr(obj);
36964 obj_conv.is_owned = ptr_is_owned(obj);
36965 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36966 obj_conv.is_owned = false;
36967 LDKCVec_u8Z ret_var = WarningMessage_write(&obj_conv);
36968 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36969 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36970 CVec_u8Z_free(ret_var);
36974 uint64_t __attribute__((export_name("TS_WarningMessage_read"))) TS_WarningMessage_read(int8_tArray ser) {
36975 LDKu8slice ser_ref;
36976 ser_ref.datalen = ser->arr_len;
36977 ser_ref.data = ser->elems;
36978 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
36979 *ret_conv = WarningMessage_read(ser_ref);
36981 return tag_ptr(ret_conv, true);
36984 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_write"))) TS_UnsignedNodeAnnouncement_write(uint64_t obj) {
36985 LDKUnsignedNodeAnnouncement obj_conv;
36986 obj_conv.inner = untag_ptr(obj);
36987 obj_conv.is_owned = ptr_is_owned(obj);
36988 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36989 obj_conv.is_owned = false;
36990 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
36991 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36992 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36993 CVec_u8Z_free(ret_var);
36997 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_read"))) TS_UnsignedNodeAnnouncement_read(int8_tArray ser) {
36998 LDKu8slice ser_ref;
36999 ser_ref.datalen = ser->arr_len;
37000 ser_ref.data = ser->elems;
37001 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
37002 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
37004 return tag_ptr(ret_conv, true);
37007 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_write"))) TS_NodeAnnouncement_write(uint64_t obj) {
37008 LDKNodeAnnouncement obj_conv;
37009 obj_conv.inner = untag_ptr(obj);
37010 obj_conv.is_owned = ptr_is_owned(obj);
37011 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37012 obj_conv.is_owned = false;
37013 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
37014 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37015 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37016 CVec_u8Z_free(ret_var);
37020 uint64_t __attribute__((export_name("TS_NodeAnnouncement_read"))) TS_NodeAnnouncement_read(int8_tArray ser) {
37021 LDKu8slice ser_ref;
37022 ser_ref.datalen = ser->arr_len;
37023 ser_ref.data = ser->elems;
37024 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
37025 *ret_conv = NodeAnnouncement_read(ser_ref);
37027 return tag_ptr(ret_conv, true);
37030 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_read"))) TS_QueryShortChannelIds_read(int8_tArray ser) {
37031 LDKu8slice ser_ref;
37032 ser_ref.datalen = ser->arr_len;
37033 ser_ref.data = ser->elems;
37034 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
37035 *ret_conv = QueryShortChannelIds_read(ser_ref);
37037 return tag_ptr(ret_conv, true);
37040 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_write"))) TS_QueryShortChannelIds_write(uint64_t obj) {
37041 LDKQueryShortChannelIds obj_conv;
37042 obj_conv.inner = untag_ptr(obj);
37043 obj_conv.is_owned = ptr_is_owned(obj);
37044 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37045 obj_conv.is_owned = false;
37046 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
37047 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37048 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37049 CVec_u8Z_free(ret_var);
37053 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_write"))) TS_ReplyShortChannelIdsEnd_write(uint64_t obj) {
37054 LDKReplyShortChannelIdsEnd obj_conv;
37055 obj_conv.inner = untag_ptr(obj);
37056 obj_conv.is_owned = ptr_is_owned(obj);
37057 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37058 obj_conv.is_owned = false;
37059 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
37060 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37061 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37062 CVec_u8Z_free(ret_var);
37066 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_read"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) {
37067 LDKu8slice ser_ref;
37068 ser_ref.datalen = ser->arr_len;
37069 ser_ref.data = ser->elems;
37070 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
37071 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
37073 return tag_ptr(ret_conv, true);
37076 int32_t __attribute__((export_name("TS_QueryChannelRange_end_blocknum"))) TS_QueryChannelRange_end_blocknum(uint64_t this_arg) {
37077 LDKQueryChannelRange this_arg_conv;
37078 this_arg_conv.inner = untag_ptr(this_arg);
37079 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37080 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37081 this_arg_conv.is_owned = false;
37082 int32_t ret_conv = QueryChannelRange_end_blocknum(&this_arg_conv);
37086 int8_tArray __attribute__((export_name("TS_QueryChannelRange_write"))) TS_QueryChannelRange_write(uint64_t obj) {
37087 LDKQueryChannelRange obj_conv;
37088 obj_conv.inner = untag_ptr(obj);
37089 obj_conv.is_owned = ptr_is_owned(obj);
37090 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37091 obj_conv.is_owned = false;
37092 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
37093 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37094 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37095 CVec_u8Z_free(ret_var);
37099 uint64_t __attribute__((export_name("TS_QueryChannelRange_read"))) TS_QueryChannelRange_read(int8_tArray ser) {
37100 LDKu8slice ser_ref;
37101 ser_ref.datalen = ser->arr_len;
37102 ser_ref.data = ser->elems;
37103 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
37104 *ret_conv = QueryChannelRange_read(ser_ref);
37106 return tag_ptr(ret_conv, true);
37109 uint64_t __attribute__((export_name("TS_ReplyChannelRange_read"))) TS_ReplyChannelRange_read(int8_tArray ser) {
37110 LDKu8slice ser_ref;
37111 ser_ref.datalen = ser->arr_len;
37112 ser_ref.data = ser->elems;
37113 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
37114 *ret_conv = ReplyChannelRange_read(ser_ref);
37116 return tag_ptr(ret_conv, true);
37119 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_write"))) TS_ReplyChannelRange_write(uint64_t obj) {
37120 LDKReplyChannelRange obj_conv;
37121 obj_conv.inner = untag_ptr(obj);
37122 obj_conv.is_owned = ptr_is_owned(obj);
37123 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37124 obj_conv.is_owned = false;
37125 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
37126 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37127 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37128 CVec_u8Z_free(ret_var);
37132 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_write"))) TS_GossipTimestampFilter_write(uint64_t obj) {
37133 LDKGossipTimestampFilter obj_conv;
37134 obj_conv.inner = untag_ptr(obj);
37135 obj_conv.is_owned = ptr_is_owned(obj);
37136 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37137 obj_conv.is_owned = false;
37138 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
37139 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37140 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37141 CVec_u8Z_free(ret_var);
37145 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_read"))) TS_GossipTimestampFilter_read(int8_tArray ser) {
37146 LDKu8slice ser_ref;
37147 ser_ref.datalen = ser->arr_len;
37148 ser_ref.data = ser->elems;
37149 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
37150 *ret_conv = GossipTimestampFilter_read(ser_ref);
37152 return tag_ptr(ret_conv, true);
37155 void __attribute__((export_name("TS_CustomMessageHandler_free"))) TS_CustomMessageHandler_free(uint64_t this_ptr) {
37156 if (!ptr_is_owned(this_ptr)) return;
37157 void* this_ptr_ptr = untag_ptr(this_ptr);
37158 CHECK_ACCESS(this_ptr_ptr);
37159 LDKCustomMessageHandler this_ptr_conv = *(LDKCustomMessageHandler*)(this_ptr_ptr);
37160 FREE(untag_ptr(this_ptr));
37161 CustomMessageHandler_free(this_ptr_conv);
37164 void __attribute__((export_name("TS_IgnoringMessageHandler_free"))) TS_IgnoringMessageHandler_free(uint64_t this_obj) {
37165 LDKIgnoringMessageHandler this_obj_conv;
37166 this_obj_conv.inner = untag_ptr(this_obj);
37167 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37169 IgnoringMessageHandler_free(this_obj_conv);
37172 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_new"))) TS_IgnoringMessageHandler_new() {
37173 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
37174 uint64_t ret_ref = 0;
37175 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37176 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37180 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_MessageSendEventsProvider"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
37181 LDKIgnoringMessageHandler this_arg_conv;
37182 this_arg_conv.inner = untag_ptr(this_arg);
37183 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37185 this_arg_conv.is_owned = false;
37186 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
37187 *ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
37188 return tag_ptr(ret_ret, true);
37191 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_RoutingMessageHandler"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint64_t this_arg) {
37192 LDKIgnoringMessageHandler this_arg_conv;
37193 this_arg_conv.inner = untag_ptr(this_arg);
37194 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37196 this_arg_conv.is_owned = false;
37197 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
37198 *ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
37199 return tag_ptr(ret_ret, true);
37202 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageProvider"))) TS_IgnoringMessageHandler_as_OnionMessageProvider(uint64_t this_arg) {
37203 LDKIgnoringMessageHandler this_arg_conv;
37204 this_arg_conv.inner = untag_ptr(this_arg);
37205 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37207 this_arg_conv.is_owned = false;
37208 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
37209 *ret_ret = IgnoringMessageHandler_as_OnionMessageProvider(&this_arg_conv);
37210 return tag_ptr(ret_ret, true);
37213 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageHandler"))) TS_IgnoringMessageHandler_as_OnionMessageHandler(uint64_t this_arg) {
37214 LDKIgnoringMessageHandler this_arg_conv;
37215 this_arg_conv.inner = untag_ptr(this_arg);
37216 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37218 this_arg_conv.is_owned = false;
37219 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
37220 *ret_ret = IgnoringMessageHandler_as_OnionMessageHandler(&this_arg_conv);
37221 return tag_ptr(ret_ret, true);
37224 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomOnionMessageHandler"))) TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(uint64_t this_arg) {
37225 LDKIgnoringMessageHandler this_arg_conv;
37226 this_arg_conv.inner = untag_ptr(this_arg);
37227 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37228 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37229 this_arg_conv.is_owned = false;
37230 LDKCustomOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
37231 *ret_ret = IgnoringMessageHandler_as_CustomOnionMessageHandler(&this_arg_conv);
37232 return tag_ptr(ret_ret, true);
37235 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageReader"))) TS_IgnoringMessageHandler_as_CustomMessageReader(uint64_t this_arg) {
37236 LDKIgnoringMessageHandler this_arg_conv;
37237 this_arg_conv.inner = untag_ptr(this_arg);
37238 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37239 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37240 this_arg_conv.is_owned = false;
37241 LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
37242 *ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
37243 return tag_ptr(ret_ret, true);
37246 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageHandler"))) TS_IgnoringMessageHandler_as_CustomMessageHandler(uint64_t this_arg) {
37247 LDKIgnoringMessageHandler this_arg_conv;
37248 this_arg_conv.inner = untag_ptr(this_arg);
37249 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37251 this_arg_conv.is_owned = false;
37252 LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
37253 *ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
37254 return tag_ptr(ret_ret, true);
37257 void __attribute__((export_name("TS_ErroringMessageHandler_free"))) TS_ErroringMessageHandler_free(uint64_t this_obj) {
37258 LDKErroringMessageHandler this_obj_conv;
37259 this_obj_conv.inner = untag_ptr(this_obj);
37260 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37262 ErroringMessageHandler_free(this_obj_conv);
37265 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_new"))) TS_ErroringMessageHandler_new() {
37266 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
37267 uint64_t ret_ref = 0;
37268 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37269 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37273 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_MessageSendEventsProvider"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
37274 LDKErroringMessageHandler this_arg_conv;
37275 this_arg_conv.inner = untag_ptr(this_arg);
37276 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37278 this_arg_conv.is_owned = false;
37279 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
37280 *ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
37281 return tag_ptr(ret_ret, true);
37284 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_ChannelMessageHandler"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint64_t this_arg) {
37285 LDKErroringMessageHandler this_arg_conv;
37286 this_arg_conv.inner = untag_ptr(this_arg);
37287 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37289 this_arg_conv.is_owned = false;
37290 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
37291 *ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
37292 return tag_ptr(ret_ret, true);
37295 void __attribute__((export_name("TS_MessageHandler_free"))) TS_MessageHandler_free(uint64_t this_obj) {
37296 LDKMessageHandler this_obj_conv;
37297 this_obj_conv.inner = untag_ptr(this_obj);
37298 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37299 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37300 MessageHandler_free(this_obj_conv);
37303 uint64_t __attribute__((export_name("TS_MessageHandler_get_chan_handler"))) TS_MessageHandler_get_chan_handler(uint64_t this_ptr) {
37304 LDKMessageHandler this_ptr_conv;
37305 this_ptr_conv.inner = untag_ptr(this_ptr);
37306 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37308 this_ptr_conv.is_owned = false;
37309 // WARNING: This object doesn't live past this scope, needs clone!
37310 uint64_t ret_ret = tag_ptr(MessageHandler_get_chan_handler(&this_ptr_conv), false);
37314 void __attribute__((export_name("TS_MessageHandler_set_chan_handler"))) TS_MessageHandler_set_chan_handler(uint64_t this_ptr, uint64_t val) {
37315 LDKMessageHandler this_ptr_conv;
37316 this_ptr_conv.inner = untag_ptr(this_ptr);
37317 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37318 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37319 this_ptr_conv.is_owned = false;
37320 void* val_ptr = untag_ptr(val);
37321 CHECK_ACCESS(val_ptr);
37322 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
37323 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
37324 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37325 LDKChannelMessageHandler_JCalls_cloned(&val_conv);
37327 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
37330 uint64_t __attribute__((export_name("TS_MessageHandler_get_route_handler"))) TS_MessageHandler_get_route_handler(uint64_t this_ptr) {
37331 LDKMessageHandler this_ptr_conv;
37332 this_ptr_conv.inner = untag_ptr(this_ptr);
37333 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37335 this_ptr_conv.is_owned = false;
37336 // WARNING: This object doesn't live past this scope, needs clone!
37337 uint64_t ret_ret = tag_ptr(MessageHandler_get_route_handler(&this_ptr_conv), false);
37341 void __attribute__((export_name("TS_MessageHandler_set_route_handler"))) TS_MessageHandler_set_route_handler(uint64_t this_ptr, uint64_t val) {
37342 LDKMessageHandler this_ptr_conv;
37343 this_ptr_conv.inner = untag_ptr(this_ptr);
37344 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37346 this_ptr_conv.is_owned = false;
37347 void* val_ptr = untag_ptr(val);
37348 CHECK_ACCESS(val_ptr);
37349 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
37350 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
37351 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37352 LDKRoutingMessageHandler_JCalls_cloned(&val_conv);
37354 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
37357 uint64_t __attribute__((export_name("TS_MessageHandler_get_onion_message_handler"))) TS_MessageHandler_get_onion_message_handler(uint64_t this_ptr) {
37358 LDKMessageHandler this_ptr_conv;
37359 this_ptr_conv.inner = untag_ptr(this_ptr);
37360 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37361 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37362 this_ptr_conv.is_owned = false;
37363 // WARNING: This object doesn't live past this scope, needs clone!
37364 uint64_t ret_ret = tag_ptr(MessageHandler_get_onion_message_handler(&this_ptr_conv), false);
37368 void __attribute__((export_name("TS_MessageHandler_set_onion_message_handler"))) TS_MessageHandler_set_onion_message_handler(uint64_t this_ptr, uint64_t val) {
37369 LDKMessageHandler this_ptr_conv;
37370 this_ptr_conv.inner = untag_ptr(this_ptr);
37371 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37372 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37373 this_ptr_conv.is_owned = false;
37374 void* val_ptr = untag_ptr(val);
37375 CHECK_ACCESS(val_ptr);
37376 LDKOnionMessageHandler val_conv = *(LDKOnionMessageHandler*)(val_ptr);
37377 if (val_conv.free == LDKOnionMessageHandler_JCalls_free) {
37378 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37379 LDKOnionMessageHandler_JCalls_cloned(&val_conv);
37381 MessageHandler_set_onion_message_handler(&this_ptr_conv, val_conv);
37384 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) {
37385 void* chan_handler_arg_ptr = untag_ptr(chan_handler_arg);
37386 CHECK_ACCESS(chan_handler_arg_ptr);
37387 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(chan_handler_arg_ptr);
37388 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
37389 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37390 LDKChannelMessageHandler_JCalls_cloned(&chan_handler_arg_conv);
37392 void* route_handler_arg_ptr = untag_ptr(route_handler_arg);
37393 CHECK_ACCESS(route_handler_arg_ptr);
37394 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(route_handler_arg_ptr);
37395 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
37396 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37397 LDKRoutingMessageHandler_JCalls_cloned(&route_handler_arg_conv);
37399 void* onion_message_handler_arg_ptr = untag_ptr(onion_message_handler_arg);
37400 CHECK_ACCESS(onion_message_handler_arg_ptr);
37401 LDKOnionMessageHandler onion_message_handler_arg_conv = *(LDKOnionMessageHandler*)(onion_message_handler_arg_ptr);
37402 if (onion_message_handler_arg_conv.free == LDKOnionMessageHandler_JCalls_free) {
37403 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37404 LDKOnionMessageHandler_JCalls_cloned(&onion_message_handler_arg_conv);
37406 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv, onion_message_handler_arg_conv);
37407 uint64_t ret_ref = 0;
37408 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37409 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37413 static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
37414 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
37415 *ret_ret = SocketDescriptor_clone(arg);
37416 return tag_ptr(ret_ret, true);
37418 int64_t __attribute__((export_name("TS_SocketDescriptor_clone_ptr"))) TS_SocketDescriptor_clone_ptr(uint64_t arg) {
37419 void* arg_ptr = untag_ptr(arg);
37420 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
37421 LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
37422 int64_t ret_conv = SocketDescriptor_clone_ptr(arg_conv);
37426 uint64_t __attribute__((export_name("TS_SocketDescriptor_clone"))) TS_SocketDescriptor_clone(uint64_t orig) {
37427 void* orig_ptr = untag_ptr(orig);
37428 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
37429 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)orig_ptr;
37430 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
37431 *ret_ret = SocketDescriptor_clone(orig_conv);
37432 return tag_ptr(ret_ret, true);
37435 void __attribute__((export_name("TS_SocketDescriptor_free"))) TS_SocketDescriptor_free(uint64_t this_ptr) {
37436 if (!ptr_is_owned(this_ptr)) return;
37437 void* this_ptr_ptr = untag_ptr(this_ptr);
37438 CHECK_ACCESS(this_ptr_ptr);
37439 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(this_ptr_ptr);
37440 FREE(untag_ptr(this_ptr));
37441 SocketDescriptor_free(this_ptr_conv);
37444 void __attribute__((export_name("TS_PeerHandleError_free"))) TS_PeerHandleError_free(uint64_t this_obj) {
37445 LDKPeerHandleError this_obj_conv;
37446 this_obj_conv.inner = untag_ptr(this_obj);
37447 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37448 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37449 PeerHandleError_free(this_obj_conv);
37452 uint64_t __attribute__((export_name("TS_PeerHandleError_new"))) TS_PeerHandleError_new() {
37453 LDKPeerHandleError ret_var = PeerHandleError_new();
37454 uint64_t ret_ref = 0;
37455 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37456 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37460 static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
37461 LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
37462 uint64_t ret_ref = 0;
37463 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37464 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37467 int64_t __attribute__((export_name("TS_PeerHandleError_clone_ptr"))) TS_PeerHandleError_clone_ptr(uint64_t arg) {
37468 LDKPeerHandleError arg_conv;
37469 arg_conv.inner = untag_ptr(arg);
37470 arg_conv.is_owned = ptr_is_owned(arg);
37471 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37472 arg_conv.is_owned = false;
37473 int64_t ret_conv = PeerHandleError_clone_ptr(&arg_conv);
37477 uint64_t __attribute__((export_name("TS_PeerHandleError_clone"))) TS_PeerHandleError_clone(uint64_t orig) {
37478 LDKPeerHandleError orig_conv;
37479 orig_conv.inner = untag_ptr(orig);
37480 orig_conv.is_owned = ptr_is_owned(orig);
37481 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37482 orig_conv.is_owned = false;
37483 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
37484 uint64_t ret_ref = 0;
37485 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37486 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37490 void __attribute__((export_name("TS_PeerManager_free"))) TS_PeerManager_free(uint64_t this_obj) {
37491 LDKPeerManager this_obj_conv;
37492 this_obj_conv.inner = untag_ptr(this_obj);
37493 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37495 PeerManager_free(this_obj_conv);
37498 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) {
37499 LDKMessageHandler message_handler_conv;
37500 message_handler_conv.inner = untag_ptr(message_handler);
37501 message_handler_conv.is_owned = ptr_is_owned(message_handler);
37502 CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
37503 // WARNING: we need a move here but no clone is available for LDKMessageHandler
37505 uint8_t ephemeral_random_data_arr[32];
37506 CHECK(ephemeral_random_data->arr_len == 32);
37507 memcpy(ephemeral_random_data_arr, ephemeral_random_data->elems, 32); FREE(ephemeral_random_data);
37508 uint8_t (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
37509 void* logger_ptr = untag_ptr(logger);
37510 CHECK_ACCESS(logger_ptr);
37511 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
37512 if (logger_conv.free == LDKLogger_JCalls_free) {
37513 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37514 LDKLogger_JCalls_cloned(&logger_conv);
37516 void* custom_message_handler_ptr = untag_ptr(custom_message_handler);
37517 CHECK_ACCESS(custom_message_handler_ptr);
37518 LDKCustomMessageHandler custom_message_handler_conv = *(LDKCustomMessageHandler*)(custom_message_handler_ptr);
37519 if (custom_message_handler_conv.free == LDKCustomMessageHandler_JCalls_free) {
37520 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37521 LDKCustomMessageHandler_JCalls_cloned(&custom_message_handler_conv);
37523 void* node_signer_ptr = untag_ptr(node_signer);
37524 CHECK_ACCESS(node_signer_ptr);
37525 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
37526 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
37527 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37528 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
37530 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, current_time, ephemeral_random_data_ref, logger_conv, custom_message_handler_conv, node_signer_conv);
37531 uint64_t ret_ref = 0;
37532 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37533 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37537 uint64_tArray __attribute__((export_name("TS_PeerManager_get_peer_node_ids"))) TS_PeerManager_get_peer_node_ids(uint64_t this_arg) {
37538 LDKPeerManager this_arg_conv;
37539 this_arg_conv.inner = untag_ptr(this_arg);
37540 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37542 this_arg_conv.is_owned = false;
37543 LDKCVec_C2Tuple_PublicKeyCOption_NetAddressZZZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
37544 uint64_tArray ret_arr = NULL;
37545 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
37546 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
37547 for (size_t o = 0; o < ret_var.datalen; o++) {
37548 LDKC2Tuple_PublicKeyCOption_NetAddressZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_NetAddressZZ), "LDKC2Tuple_PublicKeyCOption_NetAddressZZ");
37549 *ret_conv_40_conv = ret_var.data[o];
37550 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
37553 FREE(ret_var.data);
37557 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) {
37558 LDKPeerManager this_arg_conv;
37559 this_arg_conv.inner = untag_ptr(this_arg);
37560 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37561 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37562 this_arg_conv.is_owned = false;
37563 LDKPublicKey their_node_id_ref;
37564 CHECK(their_node_id->arr_len == 33);
37565 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
37566 void* descriptor_ptr = untag_ptr(descriptor);
37567 CHECK_ACCESS(descriptor_ptr);
37568 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
37569 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
37570 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37571 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
37573 void* remote_network_address_ptr = untag_ptr(remote_network_address);
37574 CHECK_ACCESS(remote_network_address_ptr);
37575 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
37576 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
37577 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv, remote_network_address_conv);
37578 return tag_ptr(ret_conv, true);
37581 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) {
37582 LDKPeerManager this_arg_conv;
37583 this_arg_conv.inner = untag_ptr(this_arg);
37584 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37586 this_arg_conv.is_owned = false;
37587 void* descriptor_ptr = untag_ptr(descriptor);
37588 CHECK_ACCESS(descriptor_ptr);
37589 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
37590 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
37591 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
37592 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
37594 void* remote_network_address_ptr = untag_ptr(remote_network_address);
37595 CHECK_ACCESS(remote_network_address_ptr);
37596 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
37597 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
37598 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv, remote_network_address_conv);
37599 return tag_ptr(ret_conv, true);
37602 uint64_t __attribute__((export_name("TS_PeerManager_write_buffer_space_avail"))) TS_PeerManager_write_buffer_space_avail(uint64_t this_arg, uint64_t descriptor) {
37603 LDKPeerManager this_arg_conv;
37604 this_arg_conv.inner = untag_ptr(this_arg);
37605 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37607 this_arg_conv.is_owned = false;
37608 void* descriptor_ptr = untag_ptr(descriptor);
37609 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
37610 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
37611 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
37612 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
37613 return tag_ptr(ret_conv, true);
37616 uint64_t __attribute__((export_name("TS_PeerManager_read_event"))) TS_PeerManager_read_event(uint64_t this_arg, uint64_t peer_descriptor, int8_tArray data) {
37617 LDKPeerManager this_arg_conv;
37618 this_arg_conv.inner = untag_ptr(this_arg);
37619 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37620 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37621 this_arg_conv.is_owned = false;
37622 void* peer_descriptor_ptr = untag_ptr(peer_descriptor);
37623 if (ptr_is_owned(peer_descriptor)) { CHECK_ACCESS(peer_descriptor_ptr); }
37624 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
37625 LDKu8slice data_ref;
37626 data_ref.datalen = data->arr_len;
37627 data_ref.data = data->elems;
37628 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
37629 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
37631 return tag_ptr(ret_conv, true);
37634 void __attribute__((export_name("TS_PeerManager_process_events"))) TS_PeerManager_process_events(uint64_t this_arg) {
37635 LDKPeerManager this_arg_conv;
37636 this_arg_conv.inner = untag_ptr(this_arg);
37637 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37639 this_arg_conv.is_owned = false;
37640 PeerManager_process_events(&this_arg_conv);
37643 void __attribute__((export_name("TS_PeerManager_socket_disconnected"))) TS_PeerManager_socket_disconnected(uint64_t this_arg, uint64_t descriptor) {
37644 LDKPeerManager this_arg_conv;
37645 this_arg_conv.inner = untag_ptr(this_arg);
37646 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37648 this_arg_conv.is_owned = false;
37649 void* descriptor_ptr = untag_ptr(descriptor);
37650 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
37651 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
37652 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
37655 void __attribute__((export_name("TS_PeerManager_disconnect_by_node_id"))) TS_PeerManager_disconnect_by_node_id(uint64_t this_arg, int8_tArray node_id) {
37656 LDKPeerManager this_arg_conv;
37657 this_arg_conv.inner = untag_ptr(this_arg);
37658 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37659 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37660 this_arg_conv.is_owned = false;
37661 LDKPublicKey node_id_ref;
37662 CHECK(node_id->arr_len == 33);
37663 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
37664 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref);
37667 void __attribute__((export_name("TS_PeerManager_disconnect_all_peers"))) TS_PeerManager_disconnect_all_peers(uint64_t this_arg) {
37668 LDKPeerManager this_arg_conv;
37669 this_arg_conv.inner = untag_ptr(this_arg);
37670 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37672 this_arg_conv.is_owned = false;
37673 PeerManager_disconnect_all_peers(&this_arg_conv);
37676 void __attribute__((export_name("TS_PeerManager_timer_tick_occurred"))) TS_PeerManager_timer_tick_occurred(uint64_t this_arg) {
37677 LDKPeerManager this_arg_conv;
37678 this_arg_conv.inner = untag_ptr(this_arg);
37679 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37681 this_arg_conv.is_owned = false;
37682 PeerManager_timer_tick_occurred(&this_arg_conv);
37685 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) {
37686 LDKPeerManager this_arg_conv;
37687 this_arg_conv.inner = untag_ptr(this_arg);
37688 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37690 this_arg_conv.is_owned = false;
37691 LDKThreeBytes rgb_ref;
37692 CHECK(rgb->arr_len == 3);
37693 memcpy(rgb_ref.data, rgb->elems, 3); FREE(rgb);
37694 LDKThirtyTwoBytes alias_ref;
37695 CHECK(alias->arr_len == 32);
37696 memcpy(alias_ref.data, alias->elems, 32); FREE(alias);
37697 LDKCVec_NetAddressZ addresses_constr;
37698 addresses_constr.datalen = addresses->arr_len;
37699 if (addresses_constr.datalen > 0)
37700 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
37702 addresses_constr.data = NULL;
37703 uint64_t* addresses_vals = addresses->elems;
37704 for (size_t m = 0; m < addresses_constr.datalen; m++) {
37705 uint64_t addresses_conv_12 = addresses_vals[m];
37706 void* addresses_conv_12_ptr = untag_ptr(addresses_conv_12);
37707 CHECK_ACCESS(addresses_conv_12_ptr);
37708 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(addresses_conv_12_ptr);
37709 addresses_constr.data[m] = addresses_conv_12_conv;
37712 PeerManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
37715 int64_t __attribute__((export_name("TS_htlc_success_tx_weight"))) TS_htlc_success_tx_weight(jboolean opt_anchors) {
37716 int64_t ret_conv = htlc_success_tx_weight(opt_anchors);
37720 int64_t __attribute__((export_name("TS_htlc_timeout_tx_weight"))) TS_htlc_timeout_tx_weight(jboolean opt_anchors) {
37721 int64_t ret_conv = htlc_timeout_tx_weight(opt_anchors);
37725 uint32_t __attribute__((export_name("TS_HTLCClaim_clone"))) TS_HTLCClaim_clone(uint64_t orig) {
37726 LDKHTLCClaim* orig_conv = (LDKHTLCClaim*)untag_ptr(orig);
37727 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_clone(orig_conv));
37731 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_timeout"))) TS_HTLCClaim_offered_timeout() {
37732 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_timeout());
37736 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_preimage"))) TS_HTLCClaim_offered_preimage() {
37737 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_preimage());
37741 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_timeout"))) TS_HTLCClaim_accepted_timeout() {
37742 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_timeout());
37746 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_preimage"))) TS_HTLCClaim_accepted_preimage() {
37747 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_preimage());
37751 uint32_t __attribute__((export_name("TS_HTLCClaim_revocation"))) TS_HTLCClaim_revocation() {
37752 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_revocation());
37756 jboolean __attribute__((export_name("TS_HTLCClaim_eq"))) TS_HTLCClaim_eq(uint64_t a, uint64_t b) {
37757 LDKHTLCClaim* a_conv = (LDKHTLCClaim*)untag_ptr(a);
37758 LDKHTLCClaim* b_conv = (LDKHTLCClaim*)untag_ptr(b);
37759 jboolean ret_conv = HTLCClaim_eq(a_conv, b_conv);
37763 uint64_t __attribute__((export_name("TS_HTLCClaim_from_witness"))) TS_HTLCClaim_from_witness(int8_tArray witness) {
37764 LDKWitness witness_ref;
37765 witness_ref.datalen = witness->arr_len;
37766 witness_ref.data = MALLOC(witness_ref.datalen, "LDKWitness Bytes");
37767 memcpy(witness_ref.data, witness->elems, witness_ref.datalen); FREE(witness);
37768 witness_ref.data_is_owned = true;
37769 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
37770 *ret_copy = HTLCClaim_from_witness(witness_ref);
37771 uint64_t ret_ref = tag_ptr(ret_copy, true);
37775 int8_tArray __attribute__((export_name("TS_build_commitment_secret"))) TS_build_commitment_secret(int8_tArray commitment_seed, int64_t idx) {
37776 uint8_t commitment_seed_arr[32];
37777 CHECK(commitment_seed->arr_len == 32);
37778 memcpy(commitment_seed_arr, commitment_seed->elems, 32); FREE(commitment_seed);
37779 uint8_t (*commitment_seed_ref)[32] = &commitment_seed_arr;
37780 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37781 memcpy(ret_arr->elems, build_commitment_secret(commitment_seed_ref, idx).data, 32);
37785 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) {
37786 LDKCVec_u8Z to_holder_script_ref;
37787 to_holder_script_ref.datalen = to_holder_script->arr_len;
37788 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
37789 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
37790 LDKCVec_u8Z to_counterparty_script_ref;
37791 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
37792 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
37793 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
37794 LDKOutPoint funding_outpoint_conv;
37795 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
37796 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
37797 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
37798 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
37799 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);
37800 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37801 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37802 Transaction_free(ret_var);
37806 void __attribute__((export_name("TS_CounterpartyCommitmentSecrets_free"))) TS_CounterpartyCommitmentSecrets_free(uint64_t this_obj) {
37807 LDKCounterpartyCommitmentSecrets this_obj_conv;
37808 this_obj_conv.inner = untag_ptr(this_obj);
37809 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37811 CounterpartyCommitmentSecrets_free(this_obj_conv);
37814 static inline uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg) {
37815 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(arg);
37816 uint64_t ret_ref = 0;
37817 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37818 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37821 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone_ptr"))) TS_CounterpartyCommitmentSecrets_clone_ptr(uint64_t arg) {
37822 LDKCounterpartyCommitmentSecrets arg_conv;
37823 arg_conv.inner = untag_ptr(arg);
37824 arg_conv.is_owned = ptr_is_owned(arg);
37825 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37826 arg_conv.is_owned = false;
37827 int64_t ret_conv = CounterpartyCommitmentSecrets_clone_ptr(&arg_conv);
37831 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone"))) TS_CounterpartyCommitmentSecrets_clone(uint64_t orig) {
37832 LDKCounterpartyCommitmentSecrets orig_conv;
37833 orig_conv.inner = untag_ptr(orig);
37834 orig_conv.is_owned = ptr_is_owned(orig);
37835 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37836 orig_conv.is_owned = false;
37837 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(&orig_conv);
37838 uint64_t ret_ref = 0;
37839 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37840 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37844 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_new"))) TS_CounterpartyCommitmentSecrets_new() {
37845 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_new();
37846 uint64_t ret_ref = 0;
37847 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37848 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37852 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_min_seen_secret"))) TS_CounterpartyCommitmentSecrets_get_min_seen_secret(uint64_t this_arg) {
37853 LDKCounterpartyCommitmentSecrets this_arg_conv;
37854 this_arg_conv.inner = untag_ptr(this_arg);
37855 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37857 this_arg_conv.is_owned = false;
37858 int64_t ret_conv = CounterpartyCommitmentSecrets_get_min_seen_secret(&this_arg_conv);
37862 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_provide_secret"))) TS_CounterpartyCommitmentSecrets_provide_secret(uint64_t this_arg, int64_t idx, int8_tArray secret) {
37863 LDKCounterpartyCommitmentSecrets this_arg_conv;
37864 this_arg_conv.inner = untag_ptr(this_arg);
37865 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37867 this_arg_conv.is_owned = false;
37868 LDKThirtyTwoBytes secret_ref;
37869 CHECK(secret->arr_len == 32);
37870 memcpy(secret_ref.data, secret->elems, 32); FREE(secret);
37871 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
37872 *ret_conv = CounterpartyCommitmentSecrets_provide_secret(&this_arg_conv, idx, secret_ref);
37873 return tag_ptr(ret_conv, true);
37876 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_secret"))) TS_CounterpartyCommitmentSecrets_get_secret(uint64_t this_arg, int64_t idx) {
37877 LDKCounterpartyCommitmentSecrets this_arg_conv;
37878 this_arg_conv.inner = untag_ptr(this_arg);
37879 this_arg_conv.is_owned = ptr_is_owned(this_arg);
37880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37881 this_arg_conv.is_owned = false;
37882 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37883 memcpy(ret_arr->elems, CounterpartyCommitmentSecrets_get_secret(&this_arg_conv, idx).data, 32);
37887 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_write"))) TS_CounterpartyCommitmentSecrets_write(uint64_t obj) {
37888 LDKCounterpartyCommitmentSecrets obj_conv;
37889 obj_conv.inner = untag_ptr(obj);
37890 obj_conv.is_owned = ptr_is_owned(obj);
37891 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37892 obj_conv.is_owned = false;
37893 LDKCVec_u8Z ret_var = CounterpartyCommitmentSecrets_write(&obj_conv);
37894 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37895 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37896 CVec_u8Z_free(ret_var);
37900 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_read"))) TS_CounterpartyCommitmentSecrets_read(int8_tArray ser) {
37901 LDKu8slice ser_ref;
37902 ser_ref.datalen = ser->arr_len;
37903 ser_ref.data = ser->elems;
37904 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
37905 *ret_conv = CounterpartyCommitmentSecrets_read(ser_ref);
37907 return tag_ptr(ret_conv, true);
37910 int8_tArray __attribute__((export_name("TS_derive_private_key"))) TS_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) {
37911 LDKPublicKey per_commitment_point_ref;
37912 CHECK(per_commitment_point->arr_len == 33);
37913 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37914 uint8_t base_secret_arr[32];
37915 CHECK(base_secret->arr_len == 32);
37916 memcpy(base_secret_arr, base_secret->elems, 32); FREE(base_secret);
37917 uint8_t (*base_secret_ref)[32] = &base_secret_arr;
37918 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37919 memcpy(ret_arr->elems, derive_private_key(per_commitment_point_ref, base_secret_ref).bytes, 32);
37923 int8_tArray __attribute__((export_name("TS_derive_public_key"))) TS_derive_public_key(int8_tArray per_commitment_point, int8_tArray base_point) {
37924 LDKPublicKey per_commitment_point_ref;
37925 CHECK(per_commitment_point->arr_len == 33);
37926 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37927 LDKPublicKey base_point_ref;
37928 CHECK(base_point->arr_len == 33);
37929 memcpy(base_point_ref.compressed_form, base_point->elems, 33); FREE(base_point);
37930 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37931 memcpy(ret_arr->elems, derive_public_key(per_commitment_point_ref, base_point_ref).compressed_form, 33);
37935 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) {
37936 uint8_t per_commitment_secret_arr[32];
37937 CHECK(per_commitment_secret->arr_len == 32);
37938 memcpy(per_commitment_secret_arr, per_commitment_secret->elems, 32); FREE(per_commitment_secret);
37939 uint8_t (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
37940 uint8_t countersignatory_revocation_base_secret_arr[32];
37941 CHECK(countersignatory_revocation_base_secret->arr_len == 32);
37942 memcpy(countersignatory_revocation_base_secret_arr, countersignatory_revocation_base_secret->elems, 32); FREE(countersignatory_revocation_base_secret);
37943 uint8_t (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
37944 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37945 memcpy(ret_arr->elems, derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref).bytes, 32);
37949 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) {
37950 LDKPublicKey per_commitment_point_ref;
37951 CHECK(per_commitment_point->arr_len == 33);
37952 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
37953 LDKPublicKey countersignatory_revocation_base_point_ref;
37954 CHECK(countersignatory_revocation_base_point->arr_len == 33);
37955 memcpy(countersignatory_revocation_base_point_ref.compressed_form, countersignatory_revocation_base_point->elems, 33); FREE(countersignatory_revocation_base_point);
37956 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37957 memcpy(ret_arr->elems, derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref).compressed_form, 33);
37961 void __attribute__((export_name("TS_TxCreationKeys_free"))) TS_TxCreationKeys_free(uint64_t this_obj) {
37962 LDKTxCreationKeys this_obj_conv;
37963 this_obj_conv.inner = untag_ptr(this_obj);
37964 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37966 TxCreationKeys_free(this_obj_conv);
37969 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_per_commitment_point"))) TS_TxCreationKeys_get_per_commitment_point(uint64_t this_ptr) {
37970 LDKTxCreationKeys this_ptr_conv;
37971 this_ptr_conv.inner = untag_ptr(this_ptr);
37972 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37974 this_ptr_conv.is_owned = false;
37975 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37976 memcpy(ret_arr->elems, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
37980 void __attribute__((export_name("TS_TxCreationKeys_set_per_commitment_point"))) TS_TxCreationKeys_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
37981 LDKTxCreationKeys this_ptr_conv;
37982 this_ptr_conv.inner = untag_ptr(this_ptr);
37983 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37985 this_ptr_conv.is_owned = false;
37986 LDKPublicKey val_ref;
37987 CHECK(val->arr_len == 33);
37988 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37989 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
37992 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_revocation_key"))) TS_TxCreationKeys_get_revocation_key(uint64_t this_ptr) {
37993 LDKTxCreationKeys this_ptr_conv;
37994 this_ptr_conv.inner = untag_ptr(this_ptr);
37995 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37997 this_ptr_conv.is_owned = false;
37998 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37999 memcpy(ret_arr->elems, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
38003 void __attribute__((export_name("TS_TxCreationKeys_set_revocation_key"))) TS_TxCreationKeys_set_revocation_key(uint64_t this_ptr, int8_tArray val) {
38004 LDKTxCreationKeys this_ptr_conv;
38005 this_ptr_conv.inner = untag_ptr(this_ptr);
38006 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38007 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38008 this_ptr_conv.is_owned = false;
38009 LDKPublicKey val_ref;
38010 CHECK(val->arr_len == 33);
38011 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38012 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
38015 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_htlc_key"))) TS_TxCreationKeys_get_broadcaster_htlc_key(uint64_t this_ptr) {
38016 LDKTxCreationKeys this_ptr_conv;
38017 this_ptr_conv.inner = untag_ptr(this_ptr);
38018 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38020 this_ptr_conv.is_owned = false;
38021 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38022 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
38026 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_htlc_key"))) TS_TxCreationKeys_set_broadcaster_htlc_key(uint64_t this_ptr, int8_tArray val) {
38027 LDKTxCreationKeys this_ptr_conv;
38028 this_ptr_conv.inner = untag_ptr(this_ptr);
38029 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38030 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38031 this_ptr_conv.is_owned = false;
38032 LDKPublicKey val_ref;
38033 CHECK(val->arr_len == 33);
38034 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38035 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
38038 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_countersignatory_htlc_key"))) TS_TxCreationKeys_get_countersignatory_htlc_key(uint64_t this_ptr) {
38039 LDKTxCreationKeys this_ptr_conv;
38040 this_ptr_conv.inner = untag_ptr(this_ptr);
38041 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38042 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38043 this_ptr_conv.is_owned = false;
38044 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38045 memcpy(ret_arr->elems, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
38049 void __attribute__((export_name("TS_TxCreationKeys_set_countersignatory_htlc_key"))) TS_TxCreationKeys_set_countersignatory_htlc_key(uint64_t this_ptr, int8_tArray val) {
38050 LDKTxCreationKeys this_ptr_conv;
38051 this_ptr_conv.inner = untag_ptr(this_ptr);
38052 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38053 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38054 this_ptr_conv.is_owned = false;
38055 LDKPublicKey val_ref;
38056 CHECK(val->arr_len == 33);
38057 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38058 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
38061 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_get_broadcaster_delayed_payment_key(uint64_t this_ptr) {
38062 LDKTxCreationKeys this_ptr_conv;
38063 this_ptr_conv.inner = untag_ptr(this_ptr);
38064 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38065 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38066 this_ptr_conv.is_owned = false;
38067 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38068 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
38072 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) {
38073 LDKTxCreationKeys this_ptr_conv;
38074 this_ptr_conv.inner = untag_ptr(this_ptr);
38075 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38077 this_ptr_conv.is_owned = false;
38078 LDKPublicKey val_ref;
38079 CHECK(val->arr_len == 33);
38080 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38081 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
38084 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) {
38085 LDKPublicKey per_commitment_point_arg_ref;
38086 CHECK(per_commitment_point_arg->arr_len == 33);
38087 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
38088 LDKPublicKey revocation_key_arg_ref;
38089 CHECK(revocation_key_arg->arr_len == 33);
38090 memcpy(revocation_key_arg_ref.compressed_form, revocation_key_arg->elems, 33); FREE(revocation_key_arg);
38091 LDKPublicKey broadcaster_htlc_key_arg_ref;
38092 CHECK(broadcaster_htlc_key_arg->arr_len == 33);
38093 memcpy(broadcaster_htlc_key_arg_ref.compressed_form, broadcaster_htlc_key_arg->elems, 33); FREE(broadcaster_htlc_key_arg);
38094 LDKPublicKey countersignatory_htlc_key_arg_ref;
38095 CHECK(countersignatory_htlc_key_arg->arr_len == 33);
38096 memcpy(countersignatory_htlc_key_arg_ref.compressed_form, countersignatory_htlc_key_arg->elems, 33); FREE(countersignatory_htlc_key_arg);
38097 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
38098 CHECK(broadcaster_delayed_payment_key_arg->arr_len == 33);
38099 memcpy(broadcaster_delayed_payment_key_arg_ref.compressed_form, broadcaster_delayed_payment_key_arg->elems, 33); FREE(broadcaster_delayed_payment_key_arg);
38100 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);
38101 uint64_t ret_ref = 0;
38102 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38103 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38107 jboolean __attribute__((export_name("TS_TxCreationKeys_eq"))) TS_TxCreationKeys_eq(uint64_t a, uint64_t b) {
38108 LDKTxCreationKeys a_conv;
38109 a_conv.inner = untag_ptr(a);
38110 a_conv.is_owned = ptr_is_owned(a);
38111 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38112 a_conv.is_owned = false;
38113 LDKTxCreationKeys b_conv;
38114 b_conv.inner = untag_ptr(b);
38115 b_conv.is_owned = ptr_is_owned(b);
38116 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38117 b_conv.is_owned = false;
38118 jboolean ret_conv = TxCreationKeys_eq(&a_conv, &b_conv);
38122 static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
38123 LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
38124 uint64_t ret_ref = 0;
38125 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38126 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38129 int64_t __attribute__((export_name("TS_TxCreationKeys_clone_ptr"))) TS_TxCreationKeys_clone_ptr(uint64_t arg) {
38130 LDKTxCreationKeys arg_conv;
38131 arg_conv.inner = untag_ptr(arg);
38132 arg_conv.is_owned = ptr_is_owned(arg);
38133 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38134 arg_conv.is_owned = false;
38135 int64_t ret_conv = TxCreationKeys_clone_ptr(&arg_conv);
38139 uint64_t __attribute__((export_name("TS_TxCreationKeys_clone"))) TS_TxCreationKeys_clone(uint64_t orig) {
38140 LDKTxCreationKeys orig_conv;
38141 orig_conv.inner = untag_ptr(orig);
38142 orig_conv.is_owned = ptr_is_owned(orig);
38143 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38144 orig_conv.is_owned = false;
38145 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
38146 uint64_t ret_ref = 0;
38147 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38148 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38152 int8_tArray __attribute__((export_name("TS_TxCreationKeys_write"))) TS_TxCreationKeys_write(uint64_t obj) {
38153 LDKTxCreationKeys obj_conv;
38154 obj_conv.inner = untag_ptr(obj);
38155 obj_conv.is_owned = ptr_is_owned(obj);
38156 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38157 obj_conv.is_owned = false;
38158 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
38159 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38160 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38161 CVec_u8Z_free(ret_var);
38165 uint64_t __attribute__((export_name("TS_TxCreationKeys_read"))) TS_TxCreationKeys_read(int8_tArray ser) {
38166 LDKu8slice ser_ref;
38167 ser_ref.datalen = ser->arr_len;
38168 ser_ref.data = ser->elems;
38169 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
38170 *ret_conv = TxCreationKeys_read(ser_ref);
38172 return tag_ptr(ret_conv, true);
38175 void __attribute__((export_name("TS_ChannelPublicKeys_free"))) TS_ChannelPublicKeys_free(uint64_t this_obj) {
38176 LDKChannelPublicKeys this_obj_conv;
38177 this_obj_conv.inner = untag_ptr(this_obj);
38178 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38179 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38180 ChannelPublicKeys_free(this_obj_conv);
38183 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_funding_pubkey"))) TS_ChannelPublicKeys_get_funding_pubkey(uint64_t this_ptr) {
38184 LDKChannelPublicKeys this_ptr_conv;
38185 this_ptr_conv.inner = untag_ptr(this_ptr);
38186 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38188 this_ptr_conv.is_owned = false;
38189 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38190 memcpy(ret_arr->elems, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
38194 void __attribute__((export_name("TS_ChannelPublicKeys_set_funding_pubkey"))) TS_ChannelPublicKeys_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
38195 LDKChannelPublicKeys this_ptr_conv;
38196 this_ptr_conv.inner = untag_ptr(this_ptr);
38197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38199 this_ptr_conv.is_owned = false;
38200 LDKPublicKey val_ref;
38201 CHECK(val->arr_len == 33);
38202 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38203 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
38206 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_revocation_basepoint"))) TS_ChannelPublicKeys_get_revocation_basepoint(uint64_t this_ptr) {
38207 LDKChannelPublicKeys this_ptr_conv;
38208 this_ptr_conv.inner = untag_ptr(this_ptr);
38209 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38211 this_ptr_conv.is_owned = false;
38212 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38213 memcpy(ret_arr->elems, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
38217 void __attribute__((export_name("TS_ChannelPublicKeys_set_revocation_basepoint"))) TS_ChannelPublicKeys_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
38218 LDKChannelPublicKeys this_ptr_conv;
38219 this_ptr_conv.inner = untag_ptr(this_ptr);
38220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38222 this_ptr_conv.is_owned = false;
38223 LDKPublicKey val_ref;
38224 CHECK(val->arr_len == 33);
38225 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38226 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
38229 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_payment_point"))) TS_ChannelPublicKeys_get_payment_point(uint64_t this_ptr) {
38230 LDKChannelPublicKeys this_ptr_conv;
38231 this_ptr_conv.inner = untag_ptr(this_ptr);
38232 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38234 this_ptr_conv.is_owned = false;
38235 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38236 memcpy(ret_arr->elems, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
38240 void __attribute__((export_name("TS_ChannelPublicKeys_set_payment_point"))) TS_ChannelPublicKeys_set_payment_point(uint64_t this_ptr, int8_tArray val) {
38241 LDKChannelPublicKeys this_ptr_conv;
38242 this_ptr_conv.inner = untag_ptr(this_ptr);
38243 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38245 this_ptr_conv.is_owned = false;
38246 LDKPublicKey val_ref;
38247 CHECK(val->arr_len == 33);
38248 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38249 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
38252 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_delayed_payment_basepoint"))) TS_ChannelPublicKeys_get_delayed_payment_basepoint(uint64_t this_ptr) {
38253 LDKChannelPublicKeys this_ptr_conv;
38254 this_ptr_conv.inner = untag_ptr(this_ptr);
38255 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38257 this_ptr_conv.is_owned = false;
38258 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38259 memcpy(ret_arr->elems, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
38263 void __attribute__((export_name("TS_ChannelPublicKeys_set_delayed_payment_basepoint"))) TS_ChannelPublicKeys_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
38264 LDKChannelPublicKeys this_ptr_conv;
38265 this_ptr_conv.inner = untag_ptr(this_ptr);
38266 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38268 this_ptr_conv.is_owned = false;
38269 LDKPublicKey val_ref;
38270 CHECK(val->arr_len == 33);
38271 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38272 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
38275 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_htlc_basepoint"))) TS_ChannelPublicKeys_get_htlc_basepoint(uint64_t this_ptr) {
38276 LDKChannelPublicKeys this_ptr_conv;
38277 this_ptr_conv.inner = untag_ptr(this_ptr);
38278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38280 this_ptr_conv.is_owned = false;
38281 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38282 memcpy(ret_arr->elems, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
38286 void __attribute__((export_name("TS_ChannelPublicKeys_set_htlc_basepoint"))) TS_ChannelPublicKeys_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
38287 LDKChannelPublicKeys this_ptr_conv;
38288 this_ptr_conv.inner = untag_ptr(this_ptr);
38289 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38291 this_ptr_conv.is_owned = false;
38292 LDKPublicKey val_ref;
38293 CHECK(val->arr_len == 33);
38294 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38295 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
38298 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) {
38299 LDKPublicKey funding_pubkey_arg_ref;
38300 CHECK(funding_pubkey_arg->arr_len == 33);
38301 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
38302 LDKPublicKey revocation_basepoint_arg_ref;
38303 CHECK(revocation_basepoint_arg->arr_len == 33);
38304 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
38305 LDKPublicKey payment_point_arg_ref;
38306 CHECK(payment_point_arg->arr_len == 33);
38307 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
38308 LDKPublicKey delayed_payment_basepoint_arg_ref;
38309 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
38310 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
38311 LDKPublicKey htlc_basepoint_arg_ref;
38312 CHECK(htlc_basepoint_arg->arr_len == 33);
38313 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
38314 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);
38315 uint64_t ret_ref = 0;
38316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38321 static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
38322 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
38323 uint64_t ret_ref = 0;
38324 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38325 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38328 int64_t __attribute__((export_name("TS_ChannelPublicKeys_clone_ptr"))) TS_ChannelPublicKeys_clone_ptr(uint64_t arg) {
38329 LDKChannelPublicKeys arg_conv;
38330 arg_conv.inner = untag_ptr(arg);
38331 arg_conv.is_owned = ptr_is_owned(arg);
38332 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38333 arg_conv.is_owned = false;
38334 int64_t ret_conv = ChannelPublicKeys_clone_ptr(&arg_conv);
38338 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_clone"))) TS_ChannelPublicKeys_clone(uint64_t orig) {
38339 LDKChannelPublicKeys orig_conv;
38340 orig_conv.inner = untag_ptr(orig);
38341 orig_conv.is_owned = ptr_is_owned(orig);
38342 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38343 orig_conv.is_owned = false;
38344 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
38345 uint64_t ret_ref = 0;
38346 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38347 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38351 jboolean __attribute__((export_name("TS_ChannelPublicKeys_eq"))) TS_ChannelPublicKeys_eq(uint64_t a, uint64_t b) {
38352 LDKChannelPublicKeys a_conv;
38353 a_conv.inner = untag_ptr(a);
38354 a_conv.is_owned = ptr_is_owned(a);
38355 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38356 a_conv.is_owned = false;
38357 LDKChannelPublicKeys b_conv;
38358 b_conv.inner = untag_ptr(b);
38359 b_conv.is_owned = ptr_is_owned(b);
38360 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38361 b_conv.is_owned = false;
38362 jboolean ret_conv = ChannelPublicKeys_eq(&a_conv, &b_conv);
38366 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_write"))) TS_ChannelPublicKeys_write(uint64_t obj) {
38367 LDKChannelPublicKeys obj_conv;
38368 obj_conv.inner = untag_ptr(obj);
38369 obj_conv.is_owned = ptr_is_owned(obj);
38370 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38371 obj_conv.is_owned = false;
38372 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
38373 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38374 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38375 CVec_u8Z_free(ret_var);
38379 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_read"))) TS_ChannelPublicKeys_read(int8_tArray ser) {
38380 LDKu8slice ser_ref;
38381 ser_ref.datalen = ser->arr_len;
38382 ser_ref.data = ser->elems;
38383 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
38384 *ret_conv = ChannelPublicKeys_read(ser_ref);
38386 return tag_ptr(ret_conv, true);
38389 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) {
38390 LDKPublicKey per_commitment_point_ref;
38391 CHECK(per_commitment_point->arr_len == 33);
38392 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
38393 LDKPublicKey broadcaster_delayed_payment_base_ref;
38394 CHECK(broadcaster_delayed_payment_base->arr_len == 33);
38395 memcpy(broadcaster_delayed_payment_base_ref.compressed_form, broadcaster_delayed_payment_base->elems, 33); FREE(broadcaster_delayed_payment_base);
38396 LDKPublicKey broadcaster_htlc_base_ref;
38397 CHECK(broadcaster_htlc_base->arr_len == 33);
38398 memcpy(broadcaster_htlc_base_ref.compressed_form, broadcaster_htlc_base->elems, 33); FREE(broadcaster_htlc_base);
38399 LDKPublicKey countersignatory_revocation_base_ref;
38400 CHECK(countersignatory_revocation_base->arr_len == 33);
38401 memcpy(countersignatory_revocation_base_ref.compressed_form, countersignatory_revocation_base->elems, 33); FREE(countersignatory_revocation_base);
38402 LDKPublicKey countersignatory_htlc_base_ref;
38403 CHECK(countersignatory_htlc_base->arr_len == 33);
38404 memcpy(countersignatory_htlc_base_ref.compressed_form, countersignatory_htlc_base->elems, 33); FREE(countersignatory_htlc_base);
38405 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);
38406 uint64_t ret_ref = 0;
38407 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38408 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38412 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) {
38413 LDKPublicKey per_commitment_point_ref;
38414 CHECK(per_commitment_point->arr_len == 33);
38415 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
38416 LDKChannelPublicKeys broadcaster_keys_conv;
38417 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
38418 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
38419 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
38420 broadcaster_keys_conv.is_owned = false;
38421 LDKChannelPublicKeys countersignatory_keys_conv;
38422 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
38423 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
38424 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
38425 countersignatory_keys_conv.is_owned = false;
38426 LDKTxCreationKeys ret_var = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
38427 uint64_t ret_ref = 0;
38428 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38429 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38433 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) {
38434 LDKPublicKey revocation_key_ref;
38435 CHECK(revocation_key->arr_len == 33);
38436 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
38437 LDKPublicKey broadcaster_delayed_payment_key_ref;
38438 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
38439 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
38440 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
38441 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38442 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38443 CVec_u8Z_free(ret_var);
38447 void __attribute__((export_name("TS_HTLCOutputInCommitment_free"))) TS_HTLCOutputInCommitment_free(uint64_t this_obj) {
38448 LDKHTLCOutputInCommitment this_obj_conv;
38449 this_obj_conv.inner = untag_ptr(this_obj);
38450 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38452 HTLCOutputInCommitment_free(this_obj_conv);
38455 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_get_offered"))) TS_HTLCOutputInCommitment_get_offered(uint64_t this_ptr) {
38456 LDKHTLCOutputInCommitment this_ptr_conv;
38457 this_ptr_conv.inner = untag_ptr(this_ptr);
38458 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38460 this_ptr_conv.is_owned = false;
38461 jboolean ret_conv = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
38465 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_offered"))) TS_HTLCOutputInCommitment_set_offered(uint64_t this_ptr, jboolean val) {
38466 LDKHTLCOutputInCommitment this_ptr_conv;
38467 this_ptr_conv.inner = untag_ptr(this_ptr);
38468 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38469 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38470 this_ptr_conv.is_owned = false;
38471 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
38474 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_amount_msat"))) TS_HTLCOutputInCommitment_get_amount_msat(uint64_t this_ptr) {
38475 LDKHTLCOutputInCommitment this_ptr_conv;
38476 this_ptr_conv.inner = untag_ptr(this_ptr);
38477 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38478 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38479 this_ptr_conv.is_owned = false;
38480 int64_t ret_conv = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
38484 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_amount_msat"))) TS_HTLCOutputInCommitment_set_amount_msat(uint64_t this_ptr, int64_t val) {
38485 LDKHTLCOutputInCommitment this_ptr_conv;
38486 this_ptr_conv.inner = untag_ptr(this_ptr);
38487 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38488 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38489 this_ptr_conv.is_owned = false;
38490 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
38493 int32_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_cltv_expiry"))) TS_HTLCOutputInCommitment_get_cltv_expiry(uint64_t this_ptr) {
38494 LDKHTLCOutputInCommitment this_ptr_conv;
38495 this_ptr_conv.inner = untag_ptr(this_ptr);
38496 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38497 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38498 this_ptr_conv.is_owned = false;
38499 int32_t ret_conv = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
38503 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_cltv_expiry"))) TS_HTLCOutputInCommitment_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
38504 LDKHTLCOutputInCommitment this_ptr_conv;
38505 this_ptr_conv.inner = untag_ptr(this_ptr);
38506 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38507 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38508 this_ptr_conv.is_owned = false;
38509 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
38512 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_get_payment_hash"))) TS_HTLCOutputInCommitment_get_payment_hash(uint64_t this_ptr) {
38513 LDKHTLCOutputInCommitment this_ptr_conv;
38514 this_ptr_conv.inner = untag_ptr(this_ptr);
38515 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38516 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38517 this_ptr_conv.is_owned = false;
38518 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38519 memcpy(ret_arr->elems, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
38523 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_payment_hash"))) TS_HTLCOutputInCommitment_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
38524 LDKHTLCOutputInCommitment this_ptr_conv;
38525 this_ptr_conv.inner = untag_ptr(this_ptr);
38526 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38528 this_ptr_conv.is_owned = false;
38529 LDKThirtyTwoBytes val_ref;
38530 CHECK(val->arr_len == 32);
38531 memcpy(val_ref.data, val->elems, 32); FREE(val);
38532 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
38535 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_transaction_output_index"))) TS_HTLCOutputInCommitment_get_transaction_output_index(uint64_t this_ptr) {
38536 LDKHTLCOutputInCommitment this_ptr_conv;
38537 this_ptr_conv.inner = untag_ptr(this_ptr);
38538 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38540 this_ptr_conv.is_owned = false;
38541 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
38542 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
38543 uint64_t ret_ref = tag_ptr(ret_copy, true);
38547 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_transaction_output_index"))) TS_HTLCOutputInCommitment_set_transaction_output_index(uint64_t this_ptr, uint64_t val) {
38548 LDKHTLCOutputInCommitment this_ptr_conv;
38549 this_ptr_conv.inner = untag_ptr(this_ptr);
38550 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38551 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38552 this_ptr_conv.is_owned = false;
38553 void* val_ptr = untag_ptr(val);
38554 CHECK_ACCESS(val_ptr);
38555 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
38556 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
38557 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
38560 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) {
38561 LDKThirtyTwoBytes payment_hash_arg_ref;
38562 CHECK(payment_hash_arg->arr_len == 32);
38563 memcpy(payment_hash_arg_ref.data, payment_hash_arg->elems, 32); FREE(payment_hash_arg);
38564 void* transaction_output_index_arg_ptr = untag_ptr(transaction_output_index_arg);
38565 CHECK_ACCESS(transaction_output_index_arg_ptr);
38566 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(transaction_output_index_arg_ptr);
38567 transaction_output_index_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(transaction_output_index_arg));
38568 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
38569 uint64_t ret_ref = 0;
38570 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38571 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38575 static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
38576 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
38577 uint64_t ret_ref = 0;
38578 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38579 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38582 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone_ptr"))) TS_HTLCOutputInCommitment_clone_ptr(uint64_t arg) {
38583 LDKHTLCOutputInCommitment arg_conv;
38584 arg_conv.inner = untag_ptr(arg);
38585 arg_conv.is_owned = ptr_is_owned(arg);
38586 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38587 arg_conv.is_owned = false;
38588 int64_t ret_conv = HTLCOutputInCommitment_clone_ptr(&arg_conv);
38592 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone"))) TS_HTLCOutputInCommitment_clone(uint64_t orig) {
38593 LDKHTLCOutputInCommitment orig_conv;
38594 orig_conv.inner = untag_ptr(orig);
38595 orig_conv.is_owned = ptr_is_owned(orig);
38596 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38597 orig_conv.is_owned = false;
38598 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
38599 uint64_t ret_ref = 0;
38600 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38601 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38605 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_eq"))) TS_HTLCOutputInCommitment_eq(uint64_t a, uint64_t b) {
38606 LDKHTLCOutputInCommitment a_conv;
38607 a_conv.inner = untag_ptr(a);
38608 a_conv.is_owned = ptr_is_owned(a);
38609 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38610 a_conv.is_owned = false;
38611 LDKHTLCOutputInCommitment b_conv;
38612 b_conv.inner = untag_ptr(b);
38613 b_conv.is_owned = ptr_is_owned(b);
38614 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38615 b_conv.is_owned = false;
38616 jboolean ret_conv = HTLCOutputInCommitment_eq(&a_conv, &b_conv);
38620 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_write"))) TS_HTLCOutputInCommitment_write(uint64_t obj) {
38621 LDKHTLCOutputInCommitment obj_conv;
38622 obj_conv.inner = untag_ptr(obj);
38623 obj_conv.is_owned = ptr_is_owned(obj);
38624 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38625 obj_conv.is_owned = false;
38626 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
38627 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38628 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38629 CVec_u8Z_free(ret_var);
38633 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_read"))) TS_HTLCOutputInCommitment_read(int8_tArray ser) {
38634 LDKu8slice ser_ref;
38635 ser_ref.datalen = ser->arr_len;
38636 ser_ref.data = ser->elems;
38637 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
38638 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
38640 return tag_ptr(ret_conv, true);
38643 int8_tArray __attribute__((export_name("TS_get_htlc_redeemscript"))) TS_get_htlc_redeemscript(uint64_t htlc, jboolean opt_anchors, uint64_t keys) {
38644 LDKHTLCOutputInCommitment htlc_conv;
38645 htlc_conv.inner = untag_ptr(htlc);
38646 htlc_conv.is_owned = ptr_is_owned(htlc);
38647 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
38648 htlc_conv.is_owned = false;
38649 LDKTxCreationKeys keys_conv;
38650 keys_conv.inner = untag_ptr(keys);
38651 keys_conv.is_owned = ptr_is_owned(keys);
38652 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
38653 keys_conv.is_owned = false;
38654 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, opt_anchors, &keys_conv);
38655 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38656 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38657 CVec_u8Z_free(ret_var);
38661 int8_tArray __attribute__((export_name("TS_make_funding_redeemscript"))) TS_make_funding_redeemscript(int8_tArray broadcaster, int8_tArray countersignatory) {
38662 LDKPublicKey broadcaster_ref;
38663 CHECK(broadcaster->arr_len == 33);
38664 memcpy(broadcaster_ref.compressed_form, broadcaster->elems, 33); FREE(broadcaster);
38665 LDKPublicKey countersignatory_ref;
38666 CHECK(countersignatory->arr_len == 33);
38667 memcpy(countersignatory_ref.compressed_form, countersignatory->elems, 33); FREE(countersignatory);
38668 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
38669 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38670 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38671 CVec_u8Z_free(ret_var);
38675 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) {
38676 uint8_t commitment_txid_arr[32];
38677 CHECK(commitment_txid->arr_len == 32);
38678 memcpy(commitment_txid_arr, commitment_txid->elems, 32); FREE(commitment_txid);
38679 uint8_t (*commitment_txid_ref)[32] = &commitment_txid_arr;
38680 LDKHTLCOutputInCommitment htlc_conv;
38681 htlc_conv.inner = untag_ptr(htlc);
38682 htlc_conv.is_owned = ptr_is_owned(htlc);
38683 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
38684 htlc_conv.is_owned = false;
38685 LDKPublicKey broadcaster_delayed_payment_key_ref;
38686 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
38687 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
38688 LDKPublicKey revocation_key_ref;
38689 CHECK(revocation_key->arr_len == 33);
38690 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
38691 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);
38692 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38693 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38694 Transaction_free(ret_var);
38698 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) {
38699 LDKSignature local_sig_ref;
38700 CHECK(local_sig->arr_len == 64);
38701 memcpy(local_sig_ref.compact_form, local_sig->elems, 64); FREE(local_sig);
38702 LDKSignature remote_sig_ref;
38703 CHECK(remote_sig->arr_len == 64);
38704 memcpy(remote_sig_ref.compact_form, remote_sig->elems, 64); FREE(remote_sig);
38705 LDKThirtyTwoBytes preimage_ref;
38706 CHECK(preimage->arr_len == 32);
38707 memcpy(preimage_ref.data, preimage->elems, 32); FREE(preimage);
38708 LDKu8slice redeem_script_ref;
38709 redeem_script_ref.datalen = redeem_script->arr_len;
38710 redeem_script_ref.data = redeem_script->elems;
38711 LDKWitness ret_var = build_htlc_input_witness(local_sig_ref, remote_sig_ref, preimage_ref, redeem_script_ref, opt_anchors);
38712 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38713 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38714 Witness_free(ret_var);
38715 FREE(redeem_script);
38719 int8_tArray __attribute__((export_name("TS_get_to_countersignatory_with_anchors_redeemscript"))) TS_get_to_countersignatory_with_anchors_redeemscript(int8_tArray payment_point) {
38720 LDKPublicKey payment_point_ref;
38721 CHECK(payment_point->arr_len == 33);
38722 memcpy(payment_point_ref.compressed_form, payment_point->elems, 33); FREE(payment_point);
38723 LDKCVec_u8Z ret_var = get_to_countersignatory_with_anchors_redeemscript(payment_point_ref);
38724 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38725 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38726 CVec_u8Z_free(ret_var);
38730 int8_tArray __attribute__((export_name("TS_get_anchor_redeemscript"))) TS_get_anchor_redeemscript(int8_tArray funding_pubkey) {
38731 LDKPublicKey funding_pubkey_ref;
38732 CHECK(funding_pubkey->arr_len == 33);
38733 memcpy(funding_pubkey_ref.compressed_form, funding_pubkey->elems, 33); FREE(funding_pubkey);
38734 LDKCVec_u8Z ret_var = get_anchor_redeemscript(funding_pubkey_ref);
38735 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38736 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38737 CVec_u8Z_free(ret_var);
38741 int8_tArray __attribute__((export_name("TS_build_anchor_input_witness"))) TS_build_anchor_input_witness(int8_tArray funding_key, int8_tArray funding_sig) {
38742 LDKPublicKey funding_key_ref;
38743 CHECK(funding_key->arr_len == 33);
38744 memcpy(funding_key_ref.compressed_form, funding_key->elems, 33); FREE(funding_key);
38745 LDKSignature funding_sig_ref;
38746 CHECK(funding_sig->arr_len == 64);
38747 memcpy(funding_sig_ref.compact_form, funding_sig->elems, 64); FREE(funding_sig);
38748 LDKWitness ret_var = build_anchor_input_witness(funding_key_ref, funding_sig_ref);
38749 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38750 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38751 Witness_free(ret_var);
38755 void __attribute__((export_name("TS_ChannelTransactionParameters_free"))) TS_ChannelTransactionParameters_free(uint64_t this_obj) {
38756 LDKChannelTransactionParameters this_obj_conv;
38757 this_obj_conv.inner = untag_ptr(this_obj);
38758 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38759 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38760 ChannelTransactionParameters_free(this_obj_conv);
38763 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_pubkeys"))) TS_ChannelTransactionParameters_get_holder_pubkeys(uint64_t this_ptr) {
38764 LDKChannelTransactionParameters this_ptr_conv;
38765 this_ptr_conv.inner = untag_ptr(this_ptr);
38766 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38767 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38768 this_ptr_conv.is_owned = false;
38769 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
38770 uint64_t ret_ref = 0;
38771 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38772 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38776 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_pubkeys"))) TS_ChannelTransactionParameters_set_holder_pubkeys(uint64_t this_ptr, uint64_t val) {
38777 LDKChannelTransactionParameters this_ptr_conv;
38778 this_ptr_conv.inner = untag_ptr(this_ptr);
38779 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38781 this_ptr_conv.is_owned = false;
38782 LDKChannelPublicKeys val_conv;
38783 val_conv.inner = untag_ptr(val);
38784 val_conv.is_owned = ptr_is_owned(val);
38785 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38786 val_conv = ChannelPublicKeys_clone(&val_conv);
38787 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
38790 int16_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_get_holder_selected_contest_delay(uint64_t this_ptr) {
38791 LDKChannelTransactionParameters this_ptr_conv;
38792 this_ptr_conv.inner = untag_ptr(this_ptr);
38793 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38795 this_ptr_conv.is_owned = false;
38796 int16_t ret_conv = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
38800 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) {
38801 LDKChannelTransactionParameters this_ptr_conv;
38802 this_ptr_conv.inner = untag_ptr(this_ptr);
38803 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38804 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38805 this_ptr_conv.is_owned = false;
38806 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
38809 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_get_is_outbound_from_holder"))) TS_ChannelTransactionParameters_get_is_outbound_from_holder(uint64_t this_ptr) {
38810 LDKChannelTransactionParameters this_ptr_conv;
38811 this_ptr_conv.inner = untag_ptr(this_ptr);
38812 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38813 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38814 this_ptr_conv.is_owned = false;
38815 jboolean ret_conv = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
38819 void __attribute__((export_name("TS_ChannelTransactionParameters_set_is_outbound_from_holder"))) TS_ChannelTransactionParameters_set_is_outbound_from_holder(uint64_t this_ptr, jboolean val) {
38820 LDKChannelTransactionParameters this_ptr_conv;
38821 this_ptr_conv.inner = untag_ptr(this_ptr);
38822 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38824 this_ptr_conv.is_owned = false;
38825 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
38828 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_counterparty_parameters"))) TS_ChannelTransactionParameters_get_counterparty_parameters(uint64_t this_ptr) {
38829 LDKChannelTransactionParameters this_ptr_conv;
38830 this_ptr_conv.inner = untag_ptr(this_ptr);
38831 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38832 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38833 this_ptr_conv.is_owned = false;
38834 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
38835 uint64_t ret_ref = 0;
38836 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38837 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38841 void __attribute__((export_name("TS_ChannelTransactionParameters_set_counterparty_parameters"))) TS_ChannelTransactionParameters_set_counterparty_parameters(uint64_t this_ptr, uint64_t val) {
38842 LDKChannelTransactionParameters this_ptr_conv;
38843 this_ptr_conv.inner = untag_ptr(this_ptr);
38844 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38846 this_ptr_conv.is_owned = false;
38847 LDKCounterpartyChannelTransactionParameters val_conv;
38848 val_conv.inner = untag_ptr(val);
38849 val_conv.is_owned = ptr_is_owned(val);
38850 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38851 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
38852 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
38855 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_funding_outpoint"))) TS_ChannelTransactionParameters_get_funding_outpoint(uint64_t this_ptr) {
38856 LDKChannelTransactionParameters this_ptr_conv;
38857 this_ptr_conv.inner = untag_ptr(this_ptr);
38858 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38860 this_ptr_conv.is_owned = false;
38861 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
38862 uint64_t ret_ref = 0;
38863 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38864 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38868 void __attribute__((export_name("TS_ChannelTransactionParameters_set_funding_outpoint"))) TS_ChannelTransactionParameters_set_funding_outpoint(uint64_t this_ptr, uint64_t val) {
38869 LDKChannelTransactionParameters this_ptr_conv;
38870 this_ptr_conv.inner = untag_ptr(this_ptr);
38871 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38873 this_ptr_conv.is_owned = false;
38874 LDKOutPoint val_conv;
38875 val_conv.inner = untag_ptr(val);
38876 val_conv.is_owned = ptr_is_owned(val);
38877 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38878 val_conv = OutPoint_clone(&val_conv);
38879 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
38882 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_opt_anchors"))) TS_ChannelTransactionParameters_get_opt_anchors(uint64_t this_ptr) {
38883 LDKChannelTransactionParameters this_ptr_conv;
38884 this_ptr_conv.inner = untag_ptr(this_ptr);
38885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38887 this_ptr_conv.is_owned = false;
38888 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_anchors(&this_ptr_conv));
38892 void __attribute__((export_name("TS_ChannelTransactionParameters_set_opt_anchors"))) TS_ChannelTransactionParameters_set_opt_anchors(uint64_t this_ptr, uint32_t val) {
38893 LDKChannelTransactionParameters this_ptr_conv;
38894 this_ptr_conv.inner = untag_ptr(this_ptr);
38895 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38897 this_ptr_conv.is_owned = false;
38898 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38899 ChannelTransactionParameters_set_opt_anchors(&this_ptr_conv, val_conv);
38902 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) {
38903 LDKChannelTransactionParameters this_ptr_conv;
38904 this_ptr_conv.inner = untag_ptr(this_ptr);
38905 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38907 this_ptr_conv.is_owned = false;
38908 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_non_zero_fee_anchors(&this_ptr_conv));
38912 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) {
38913 LDKChannelTransactionParameters this_ptr_conv;
38914 this_ptr_conv.inner = untag_ptr(this_ptr);
38915 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38917 this_ptr_conv.is_owned = false;
38918 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38919 ChannelTransactionParameters_set_opt_non_zero_fee_anchors(&this_ptr_conv, val_conv);
38922 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) {
38923 LDKChannelPublicKeys holder_pubkeys_arg_conv;
38924 holder_pubkeys_arg_conv.inner = untag_ptr(holder_pubkeys_arg);
38925 holder_pubkeys_arg_conv.is_owned = ptr_is_owned(holder_pubkeys_arg);
38926 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
38927 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
38928 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
38929 counterparty_parameters_arg_conv.inner = untag_ptr(counterparty_parameters_arg);
38930 counterparty_parameters_arg_conv.is_owned = ptr_is_owned(counterparty_parameters_arg);
38931 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
38932 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
38933 LDKOutPoint funding_outpoint_arg_conv;
38934 funding_outpoint_arg_conv.inner = untag_ptr(funding_outpoint_arg);
38935 funding_outpoint_arg_conv.is_owned = ptr_is_owned(funding_outpoint_arg);
38936 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
38937 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
38938 LDKCOption_NoneZ opt_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_anchors_arg);
38939 LDKCOption_NoneZ opt_non_zero_fee_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_non_zero_fee_anchors_arg);
38940 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);
38941 uint64_t ret_ref = 0;
38942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38943 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38947 static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
38948 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
38949 uint64_t ret_ref = 0;
38950 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38951 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38954 int64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone_ptr"))) TS_ChannelTransactionParameters_clone_ptr(uint64_t arg) {
38955 LDKChannelTransactionParameters arg_conv;
38956 arg_conv.inner = untag_ptr(arg);
38957 arg_conv.is_owned = ptr_is_owned(arg);
38958 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38959 arg_conv.is_owned = false;
38960 int64_t ret_conv = ChannelTransactionParameters_clone_ptr(&arg_conv);
38964 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone"))) TS_ChannelTransactionParameters_clone(uint64_t orig) {
38965 LDKChannelTransactionParameters orig_conv;
38966 orig_conv.inner = untag_ptr(orig);
38967 orig_conv.is_owned = ptr_is_owned(orig);
38968 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38969 orig_conv.is_owned = false;
38970 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
38971 uint64_t ret_ref = 0;
38972 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38973 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38977 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_eq"))) TS_ChannelTransactionParameters_eq(uint64_t a, uint64_t b) {
38978 LDKChannelTransactionParameters a_conv;
38979 a_conv.inner = untag_ptr(a);
38980 a_conv.is_owned = ptr_is_owned(a);
38981 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38982 a_conv.is_owned = false;
38983 LDKChannelTransactionParameters b_conv;
38984 b_conv.inner = untag_ptr(b);
38985 b_conv.is_owned = ptr_is_owned(b);
38986 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38987 b_conv.is_owned = false;
38988 jboolean ret_conv = ChannelTransactionParameters_eq(&a_conv, &b_conv);
38992 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_free"))) TS_CounterpartyChannelTransactionParameters_free(uint64_t this_obj) {
38993 LDKCounterpartyChannelTransactionParameters this_obj_conv;
38994 this_obj_conv.inner = untag_ptr(this_obj);
38995 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38997 CounterpartyChannelTransactionParameters_free(this_obj_conv);
39000 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_pubkeys"))) TS_CounterpartyChannelTransactionParameters_get_pubkeys(uint64_t this_ptr) {
39001 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39002 this_ptr_conv.inner = untag_ptr(this_ptr);
39003 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39004 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39005 this_ptr_conv.is_owned = false;
39006 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
39007 uint64_t ret_ref = 0;
39008 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39009 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39013 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_pubkeys"))) TS_CounterpartyChannelTransactionParameters_set_pubkeys(uint64_t this_ptr, uint64_t val) {
39014 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39015 this_ptr_conv.inner = untag_ptr(this_ptr);
39016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39018 this_ptr_conv.is_owned = false;
39019 LDKChannelPublicKeys val_conv;
39020 val_conv.inner = untag_ptr(val);
39021 val_conv.is_owned = ptr_is_owned(val);
39022 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39023 val_conv = ChannelPublicKeys_clone(&val_conv);
39024 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
39027 int16_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(uint64_t this_ptr) {
39028 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39029 this_ptr_conv.inner = untag_ptr(this_ptr);
39030 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39032 this_ptr_conv.is_owned = false;
39033 int16_t ret_conv = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
39037 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(uint64_t this_ptr, int16_t val) {
39038 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
39039 this_ptr_conv.inner = untag_ptr(this_ptr);
39040 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39042 this_ptr_conv.is_owned = false;
39043 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
39046 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_new"))) TS_CounterpartyChannelTransactionParameters_new(uint64_t pubkeys_arg, int16_t selected_contest_delay_arg) {
39047 LDKChannelPublicKeys pubkeys_arg_conv;
39048 pubkeys_arg_conv.inner = untag_ptr(pubkeys_arg);
39049 pubkeys_arg_conv.is_owned = ptr_is_owned(pubkeys_arg);
39050 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
39051 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
39052 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
39053 uint64_t ret_ref = 0;
39054 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39055 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39059 static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
39060 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
39061 uint64_t ret_ref = 0;
39062 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39063 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39066 int64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone_ptr"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint64_t arg) {
39067 LDKCounterpartyChannelTransactionParameters arg_conv;
39068 arg_conv.inner = untag_ptr(arg);
39069 arg_conv.is_owned = ptr_is_owned(arg);
39070 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39071 arg_conv.is_owned = false;
39072 int64_t ret_conv = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
39076 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone"))) TS_CounterpartyChannelTransactionParameters_clone(uint64_t orig) {
39077 LDKCounterpartyChannelTransactionParameters orig_conv;
39078 orig_conv.inner = untag_ptr(orig);
39079 orig_conv.is_owned = ptr_is_owned(orig);
39080 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39081 orig_conv.is_owned = false;
39082 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
39083 uint64_t ret_ref = 0;
39084 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39085 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39089 jboolean __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_eq"))) TS_CounterpartyChannelTransactionParameters_eq(uint64_t a, uint64_t b) {
39090 LDKCounterpartyChannelTransactionParameters a_conv;
39091 a_conv.inner = untag_ptr(a);
39092 a_conv.is_owned = ptr_is_owned(a);
39093 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39094 a_conv.is_owned = false;
39095 LDKCounterpartyChannelTransactionParameters b_conv;
39096 b_conv.inner = untag_ptr(b);
39097 b_conv.is_owned = ptr_is_owned(b);
39098 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39099 b_conv.is_owned = false;
39100 jboolean ret_conv = CounterpartyChannelTransactionParameters_eq(&a_conv, &b_conv);
39104 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_is_populated"))) TS_ChannelTransactionParameters_is_populated(uint64_t this_arg) {
39105 LDKChannelTransactionParameters this_arg_conv;
39106 this_arg_conv.inner = untag_ptr(this_arg);
39107 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39109 this_arg_conv.is_owned = false;
39110 jboolean ret_conv = ChannelTransactionParameters_is_populated(&this_arg_conv);
39114 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_holder_broadcastable"))) TS_ChannelTransactionParameters_as_holder_broadcastable(uint64_t this_arg) {
39115 LDKChannelTransactionParameters this_arg_conv;
39116 this_arg_conv.inner = untag_ptr(this_arg);
39117 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39118 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39119 this_arg_conv.is_owned = false;
39120 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
39121 uint64_t ret_ref = 0;
39122 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39123 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39127 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_counterparty_broadcastable"))) TS_ChannelTransactionParameters_as_counterparty_broadcastable(uint64_t this_arg) {
39128 LDKChannelTransactionParameters this_arg_conv;
39129 this_arg_conv.inner = untag_ptr(this_arg);
39130 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39132 this_arg_conv.is_owned = false;
39133 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
39134 uint64_t ret_ref = 0;
39135 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39136 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39140 int8_tArray __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_write"))) TS_CounterpartyChannelTransactionParameters_write(uint64_t obj) {
39141 LDKCounterpartyChannelTransactionParameters obj_conv;
39142 obj_conv.inner = untag_ptr(obj);
39143 obj_conv.is_owned = ptr_is_owned(obj);
39144 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39145 obj_conv.is_owned = false;
39146 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
39147 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39148 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39149 CVec_u8Z_free(ret_var);
39153 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_read"))) TS_CounterpartyChannelTransactionParameters_read(int8_tArray ser) {
39154 LDKu8slice ser_ref;
39155 ser_ref.datalen = ser->arr_len;
39156 ser_ref.data = ser->elems;
39157 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
39158 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
39160 return tag_ptr(ret_conv, true);
39163 int8_tArray __attribute__((export_name("TS_ChannelTransactionParameters_write"))) TS_ChannelTransactionParameters_write(uint64_t obj) {
39164 LDKChannelTransactionParameters obj_conv;
39165 obj_conv.inner = untag_ptr(obj);
39166 obj_conv.is_owned = ptr_is_owned(obj);
39167 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39168 obj_conv.is_owned = false;
39169 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
39170 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39171 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39172 CVec_u8Z_free(ret_var);
39176 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_read"))) TS_ChannelTransactionParameters_read(int8_tArray ser) {
39177 LDKu8slice ser_ref;
39178 ser_ref.datalen = ser->arr_len;
39179 ser_ref.data = ser->elems;
39180 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
39181 *ret_conv = ChannelTransactionParameters_read(ser_ref);
39183 return tag_ptr(ret_conv, true);
39186 void __attribute__((export_name("TS_DirectedChannelTransactionParameters_free"))) TS_DirectedChannelTransactionParameters_free(uint64_t this_obj) {
39187 LDKDirectedChannelTransactionParameters this_obj_conv;
39188 this_obj_conv.inner = untag_ptr(this_obj);
39189 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39191 DirectedChannelTransactionParameters_free(this_obj_conv);
39194 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_broadcaster_pubkeys"))) TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(uint64_t this_arg) {
39195 LDKDirectedChannelTransactionParameters this_arg_conv;
39196 this_arg_conv.inner = untag_ptr(this_arg);
39197 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39199 this_arg_conv.is_owned = false;
39200 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
39201 uint64_t ret_ref = 0;
39202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39207 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_countersignatory_pubkeys"))) TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(uint64_t this_arg) {
39208 LDKDirectedChannelTransactionParameters this_arg_conv;
39209 this_arg_conv.inner = untag_ptr(this_arg);
39210 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39212 this_arg_conv.is_owned = false;
39213 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
39214 uint64_t ret_ref = 0;
39215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39216 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39220 int16_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_contest_delay"))) TS_DirectedChannelTransactionParameters_contest_delay(uint64_t this_arg) {
39221 LDKDirectedChannelTransactionParameters this_arg_conv;
39222 this_arg_conv.inner = untag_ptr(this_arg);
39223 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39225 this_arg_conv.is_owned = false;
39226 int16_t ret_conv = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
39230 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_is_outbound"))) TS_DirectedChannelTransactionParameters_is_outbound(uint64_t this_arg) {
39231 LDKDirectedChannelTransactionParameters this_arg_conv;
39232 this_arg_conv.inner = untag_ptr(this_arg);
39233 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39235 this_arg_conv.is_owned = false;
39236 jboolean ret_conv = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
39240 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_funding_outpoint"))) TS_DirectedChannelTransactionParameters_funding_outpoint(uint64_t this_arg) {
39241 LDKDirectedChannelTransactionParameters this_arg_conv;
39242 this_arg_conv.inner = untag_ptr(this_arg);
39243 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39245 this_arg_conv.is_owned = false;
39246 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
39247 uint64_t ret_ref = 0;
39248 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39249 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39253 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_opt_anchors"))) TS_DirectedChannelTransactionParameters_opt_anchors(uint64_t this_arg) {
39254 LDKDirectedChannelTransactionParameters this_arg_conv;
39255 this_arg_conv.inner = untag_ptr(this_arg);
39256 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39258 this_arg_conv.is_owned = false;
39259 jboolean ret_conv = DirectedChannelTransactionParameters_opt_anchors(&this_arg_conv);
39263 void __attribute__((export_name("TS_HolderCommitmentTransaction_free"))) TS_HolderCommitmentTransaction_free(uint64_t this_obj) {
39264 LDKHolderCommitmentTransaction this_obj_conv;
39265 this_obj_conv.inner = untag_ptr(this_obj);
39266 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39268 HolderCommitmentTransaction_free(this_obj_conv);
39271 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_sig"))) TS_HolderCommitmentTransaction_get_counterparty_sig(uint64_t this_ptr) {
39272 LDKHolderCommitmentTransaction this_ptr_conv;
39273 this_ptr_conv.inner = untag_ptr(this_ptr);
39274 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39276 this_ptr_conv.is_owned = false;
39277 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39278 memcpy(ret_arr->elems, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
39282 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_sig"))) TS_HolderCommitmentTransaction_set_counterparty_sig(uint64_t this_ptr, int8_tArray val) {
39283 LDKHolderCommitmentTransaction this_ptr_conv;
39284 this_ptr_conv.inner = untag_ptr(this_ptr);
39285 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39287 this_ptr_conv.is_owned = false;
39288 LDKSignature val_ref;
39289 CHECK(val->arr_len == 64);
39290 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
39291 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
39294 ptrArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(uint64_t this_ptr) {
39295 LDKHolderCommitmentTransaction this_ptr_conv;
39296 this_ptr_conv.inner = untag_ptr(this_ptr);
39297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39299 this_ptr_conv.is_owned = false;
39300 LDKCVec_SignatureZ ret_var = HolderCommitmentTransaction_get_counterparty_htlc_sigs(&this_ptr_conv);
39301 ptrArray ret_arr = NULL;
39302 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
39303 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
39304 for (size_t m = 0; m < ret_var.datalen; m++) {
39305 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
39306 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
39307 ret_arr_ptr[m] = ret_conv_12_arr;
39310 FREE(ret_var.data);
39314 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(uint64_t this_ptr, ptrArray val) {
39315 LDKHolderCommitmentTransaction this_ptr_conv;
39316 this_ptr_conv.inner = untag_ptr(this_ptr);
39317 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39318 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39319 this_ptr_conv.is_owned = false;
39320 LDKCVec_SignatureZ val_constr;
39321 val_constr.datalen = val->arr_len;
39322 if (val_constr.datalen > 0)
39323 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
39325 val_constr.data = NULL;
39326 int8_tArray* val_vals = (void*) val->elems;
39327 for (size_t m = 0; m < val_constr.datalen; m++) {
39328 int8_tArray val_conv_12 = val_vals[m];
39329 LDKSignature val_conv_12_ref;
39330 CHECK(val_conv_12->arr_len == 64);
39331 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
39332 val_constr.data[m] = val_conv_12_ref;
39335 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
39338 static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
39339 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
39340 uint64_t ret_ref = 0;
39341 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39342 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39345 int64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone_ptr"))) TS_HolderCommitmentTransaction_clone_ptr(uint64_t arg) {
39346 LDKHolderCommitmentTransaction arg_conv;
39347 arg_conv.inner = untag_ptr(arg);
39348 arg_conv.is_owned = ptr_is_owned(arg);
39349 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39350 arg_conv.is_owned = false;
39351 int64_t ret_conv = HolderCommitmentTransaction_clone_ptr(&arg_conv);
39355 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone"))) TS_HolderCommitmentTransaction_clone(uint64_t orig) {
39356 LDKHolderCommitmentTransaction orig_conv;
39357 orig_conv.inner = untag_ptr(orig);
39358 orig_conv.is_owned = ptr_is_owned(orig);
39359 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39360 orig_conv.is_owned = false;
39361 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
39362 uint64_t ret_ref = 0;
39363 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39364 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39368 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_write"))) TS_HolderCommitmentTransaction_write(uint64_t obj) {
39369 LDKHolderCommitmentTransaction obj_conv;
39370 obj_conv.inner = untag_ptr(obj);
39371 obj_conv.is_owned = ptr_is_owned(obj);
39372 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39373 obj_conv.is_owned = false;
39374 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
39375 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39376 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39377 CVec_u8Z_free(ret_var);
39381 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_read"))) TS_HolderCommitmentTransaction_read(int8_tArray ser) {
39382 LDKu8slice ser_ref;
39383 ser_ref.datalen = ser->arr_len;
39384 ser_ref.data = ser->elems;
39385 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
39386 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
39388 return tag_ptr(ret_conv, true);
39391 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) {
39392 LDKCommitmentTransaction commitment_tx_conv;
39393 commitment_tx_conv.inner = untag_ptr(commitment_tx);
39394 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
39395 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
39396 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
39397 LDKSignature counterparty_sig_ref;
39398 CHECK(counterparty_sig->arr_len == 64);
39399 memcpy(counterparty_sig_ref.compact_form, counterparty_sig->elems, 64); FREE(counterparty_sig);
39400 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
39401 counterparty_htlc_sigs_constr.datalen = counterparty_htlc_sigs->arr_len;
39402 if (counterparty_htlc_sigs_constr.datalen > 0)
39403 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
39405 counterparty_htlc_sigs_constr.data = NULL;
39406 int8_tArray* counterparty_htlc_sigs_vals = (void*) counterparty_htlc_sigs->elems;
39407 for (size_t m = 0; m < counterparty_htlc_sigs_constr.datalen; m++) {
39408 int8_tArray counterparty_htlc_sigs_conv_12 = counterparty_htlc_sigs_vals[m];
39409 LDKSignature counterparty_htlc_sigs_conv_12_ref;
39410 CHECK(counterparty_htlc_sigs_conv_12->arr_len == 64);
39411 memcpy(counterparty_htlc_sigs_conv_12_ref.compact_form, counterparty_htlc_sigs_conv_12->elems, 64); FREE(counterparty_htlc_sigs_conv_12);
39412 counterparty_htlc_sigs_constr.data[m] = counterparty_htlc_sigs_conv_12_ref;
39414 FREE(counterparty_htlc_sigs);
39415 LDKPublicKey holder_funding_key_ref;
39416 CHECK(holder_funding_key->arr_len == 33);
39417 memcpy(holder_funding_key_ref.compressed_form, holder_funding_key->elems, 33); FREE(holder_funding_key);
39418 LDKPublicKey counterparty_funding_key_ref;
39419 CHECK(counterparty_funding_key->arr_len == 33);
39420 memcpy(counterparty_funding_key_ref.compressed_form, counterparty_funding_key->elems, 33); FREE(counterparty_funding_key);
39421 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
39422 uint64_t ret_ref = 0;
39423 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39424 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39428 void __attribute__((export_name("TS_BuiltCommitmentTransaction_free"))) TS_BuiltCommitmentTransaction_free(uint64_t this_obj) {
39429 LDKBuiltCommitmentTransaction this_obj_conv;
39430 this_obj_conv.inner = untag_ptr(this_obj);
39431 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39433 BuiltCommitmentTransaction_free(this_obj_conv);
39436 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_transaction"))) TS_BuiltCommitmentTransaction_get_transaction(uint64_t this_ptr) {
39437 LDKBuiltCommitmentTransaction this_ptr_conv;
39438 this_ptr_conv.inner = untag_ptr(this_ptr);
39439 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39440 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39441 this_ptr_conv.is_owned = false;
39442 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
39443 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39444 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39445 Transaction_free(ret_var);
39449 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_transaction"))) TS_BuiltCommitmentTransaction_set_transaction(uint64_t this_ptr, int8_tArray val) {
39450 LDKBuiltCommitmentTransaction this_ptr_conv;
39451 this_ptr_conv.inner = untag_ptr(this_ptr);
39452 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39453 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39454 this_ptr_conv.is_owned = false;
39455 LDKTransaction val_ref;
39456 val_ref.datalen = val->arr_len;
39457 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
39458 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
39459 val_ref.data_is_owned = true;
39460 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
39463 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_txid"))) TS_BuiltCommitmentTransaction_get_txid(uint64_t this_ptr) {
39464 LDKBuiltCommitmentTransaction this_ptr_conv;
39465 this_ptr_conv.inner = untag_ptr(this_ptr);
39466 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39468 this_ptr_conv.is_owned = false;
39469 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39470 memcpy(ret_arr->elems, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
39474 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_txid"))) TS_BuiltCommitmentTransaction_set_txid(uint64_t this_ptr, int8_tArray val) {
39475 LDKBuiltCommitmentTransaction this_ptr_conv;
39476 this_ptr_conv.inner = untag_ptr(this_ptr);
39477 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39478 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39479 this_ptr_conv.is_owned = false;
39480 LDKThirtyTwoBytes val_ref;
39481 CHECK(val->arr_len == 32);
39482 memcpy(val_ref.data, val->elems, 32); FREE(val);
39483 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
39486 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_new"))) TS_BuiltCommitmentTransaction_new(int8_tArray transaction_arg, int8_tArray txid_arg) {
39487 LDKTransaction transaction_arg_ref;
39488 transaction_arg_ref.datalen = transaction_arg->arr_len;
39489 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
39490 memcpy(transaction_arg_ref.data, transaction_arg->elems, transaction_arg_ref.datalen); FREE(transaction_arg);
39491 transaction_arg_ref.data_is_owned = true;
39492 LDKThirtyTwoBytes txid_arg_ref;
39493 CHECK(txid_arg->arr_len == 32);
39494 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
39495 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
39496 uint64_t ret_ref = 0;
39497 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39498 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39502 static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
39503 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
39504 uint64_t ret_ref = 0;
39505 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39506 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39509 int64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone_ptr"))) TS_BuiltCommitmentTransaction_clone_ptr(uint64_t arg) {
39510 LDKBuiltCommitmentTransaction arg_conv;
39511 arg_conv.inner = untag_ptr(arg);
39512 arg_conv.is_owned = ptr_is_owned(arg);
39513 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39514 arg_conv.is_owned = false;
39515 int64_t ret_conv = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
39519 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone"))) TS_BuiltCommitmentTransaction_clone(uint64_t orig) {
39520 LDKBuiltCommitmentTransaction orig_conv;
39521 orig_conv.inner = untag_ptr(orig);
39522 orig_conv.is_owned = ptr_is_owned(orig);
39523 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39524 orig_conv.is_owned = false;
39525 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
39526 uint64_t ret_ref = 0;
39527 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39528 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39532 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_write"))) TS_BuiltCommitmentTransaction_write(uint64_t obj) {
39533 LDKBuiltCommitmentTransaction obj_conv;
39534 obj_conv.inner = untag_ptr(obj);
39535 obj_conv.is_owned = ptr_is_owned(obj);
39536 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39537 obj_conv.is_owned = false;
39538 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
39539 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39540 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39541 CVec_u8Z_free(ret_var);
39545 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_read"))) TS_BuiltCommitmentTransaction_read(int8_tArray ser) {
39546 LDKu8slice ser_ref;
39547 ser_ref.datalen = ser->arr_len;
39548 ser_ref.data = ser->elems;
39549 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
39550 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
39552 return tag_ptr(ret_conv, true);
39555 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) {
39556 LDKBuiltCommitmentTransaction this_arg_conv;
39557 this_arg_conv.inner = untag_ptr(this_arg);
39558 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39560 this_arg_conv.is_owned = false;
39561 LDKu8slice funding_redeemscript_ref;
39562 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39563 funding_redeemscript_ref.data = funding_redeemscript->elems;
39564 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39565 memcpy(ret_arr->elems, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
39566 FREE(funding_redeemscript);
39570 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) {
39571 LDKBuiltCommitmentTransaction this_arg_conv;
39572 this_arg_conv.inner = untag_ptr(this_arg);
39573 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39575 this_arg_conv.is_owned = false;
39576 uint8_t funding_key_arr[32];
39577 CHECK(funding_key->arr_len == 32);
39578 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39579 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
39580 LDKu8slice funding_redeemscript_ref;
39581 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39582 funding_redeemscript_ref.data = funding_redeemscript->elems;
39583 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39584 memcpy(ret_arr->elems, BuiltCommitmentTransaction_sign_counterparty_commitment(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
39585 FREE(funding_redeemscript);
39589 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) {
39590 LDKBuiltCommitmentTransaction this_arg_conv;
39591 this_arg_conv.inner = untag_ptr(this_arg);
39592 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39594 this_arg_conv.is_owned = false;
39595 uint8_t funding_key_arr[32];
39596 CHECK(funding_key->arr_len == 32);
39597 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39598 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
39599 LDKu8slice funding_redeemscript_ref;
39600 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39601 funding_redeemscript_ref.data = funding_redeemscript->elems;
39602 void* entropy_source_ptr = untag_ptr(entropy_source);
39603 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
39604 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
39605 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39606 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);
39607 FREE(funding_redeemscript);
39611 void __attribute__((export_name("TS_ClosingTransaction_free"))) TS_ClosingTransaction_free(uint64_t this_obj) {
39612 LDKClosingTransaction this_obj_conv;
39613 this_obj_conv.inner = untag_ptr(this_obj);
39614 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39616 ClosingTransaction_free(this_obj_conv);
39619 static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
39620 LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
39621 uint64_t ret_ref = 0;
39622 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39623 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39626 int64_t __attribute__((export_name("TS_ClosingTransaction_clone_ptr"))) TS_ClosingTransaction_clone_ptr(uint64_t arg) {
39627 LDKClosingTransaction arg_conv;
39628 arg_conv.inner = untag_ptr(arg);
39629 arg_conv.is_owned = ptr_is_owned(arg);
39630 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39631 arg_conv.is_owned = false;
39632 int64_t ret_conv = ClosingTransaction_clone_ptr(&arg_conv);
39636 uint64_t __attribute__((export_name("TS_ClosingTransaction_clone"))) TS_ClosingTransaction_clone(uint64_t orig) {
39637 LDKClosingTransaction orig_conv;
39638 orig_conv.inner = untag_ptr(orig);
39639 orig_conv.is_owned = ptr_is_owned(orig);
39640 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39641 orig_conv.is_owned = false;
39642 LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
39643 uint64_t ret_ref = 0;
39644 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39645 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39649 int64_t __attribute__((export_name("TS_ClosingTransaction_hash"))) TS_ClosingTransaction_hash(uint64_t o) {
39650 LDKClosingTransaction o_conv;
39651 o_conv.inner = untag_ptr(o);
39652 o_conv.is_owned = ptr_is_owned(o);
39653 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
39654 o_conv.is_owned = false;
39655 int64_t ret_conv = ClosingTransaction_hash(&o_conv);
39659 jboolean __attribute__((export_name("TS_ClosingTransaction_eq"))) TS_ClosingTransaction_eq(uint64_t a, uint64_t b) {
39660 LDKClosingTransaction a_conv;
39661 a_conv.inner = untag_ptr(a);
39662 a_conv.is_owned = ptr_is_owned(a);
39663 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39664 a_conv.is_owned = false;
39665 LDKClosingTransaction b_conv;
39666 b_conv.inner = untag_ptr(b);
39667 b_conv.is_owned = ptr_is_owned(b);
39668 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39669 b_conv.is_owned = false;
39670 jboolean ret_conv = ClosingTransaction_eq(&a_conv, &b_conv);
39674 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) {
39675 LDKCVec_u8Z to_holder_script_ref;
39676 to_holder_script_ref.datalen = to_holder_script->arr_len;
39677 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
39678 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
39679 LDKCVec_u8Z to_counterparty_script_ref;
39680 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
39681 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
39682 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
39683 LDKOutPoint funding_outpoint_conv;
39684 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
39685 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
39686 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
39687 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
39688 LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
39689 uint64_t ret_ref = 0;
39690 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39691 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39695 uint64_t __attribute__((export_name("TS_ClosingTransaction_trust"))) TS_ClosingTransaction_trust(uint64_t this_arg) {
39696 LDKClosingTransaction this_arg_conv;
39697 this_arg_conv.inner = untag_ptr(this_arg);
39698 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39700 this_arg_conv.is_owned = false;
39701 LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
39702 uint64_t ret_ref = 0;
39703 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39704 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39708 uint64_t __attribute__((export_name("TS_ClosingTransaction_verify"))) TS_ClosingTransaction_verify(uint64_t this_arg, uint64_t funding_outpoint) {
39709 LDKClosingTransaction this_arg_conv;
39710 this_arg_conv.inner = untag_ptr(this_arg);
39711 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39712 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39713 this_arg_conv.is_owned = false;
39714 LDKOutPoint funding_outpoint_conv;
39715 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
39716 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
39717 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
39718 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
39719 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
39720 *ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
39721 return tag_ptr(ret_conv, true);
39724 int64_t __attribute__((export_name("TS_ClosingTransaction_to_holder_value_sat"))) TS_ClosingTransaction_to_holder_value_sat(uint64_t this_arg) {
39725 LDKClosingTransaction this_arg_conv;
39726 this_arg_conv.inner = untag_ptr(this_arg);
39727 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39729 this_arg_conv.is_owned = false;
39730 int64_t ret_conv = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
39734 int64_t __attribute__((export_name("TS_ClosingTransaction_to_counterparty_value_sat"))) TS_ClosingTransaction_to_counterparty_value_sat(uint64_t this_arg) {
39735 LDKClosingTransaction this_arg_conv;
39736 this_arg_conv.inner = untag_ptr(this_arg);
39737 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39739 this_arg_conv.is_owned = false;
39740 int64_t ret_conv = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
39744 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_holder_script"))) TS_ClosingTransaction_to_holder_script(uint64_t this_arg) {
39745 LDKClosingTransaction this_arg_conv;
39746 this_arg_conv.inner = untag_ptr(this_arg);
39747 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39748 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39749 this_arg_conv.is_owned = false;
39750 LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
39751 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39752 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39756 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_counterparty_script"))) TS_ClosingTransaction_to_counterparty_script(uint64_t this_arg) {
39757 LDKClosingTransaction this_arg_conv;
39758 this_arg_conv.inner = untag_ptr(this_arg);
39759 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39761 this_arg_conv.is_owned = false;
39762 LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
39763 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39764 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39768 void __attribute__((export_name("TS_TrustedClosingTransaction_free"))) TS_TrustedClosingTransaction_free(uint64_t this_obj) {
39769 LDKTrustedClosingTransaction this_obj_conv;
39770 this_obj_conv.inner = untag_ptr(this_obj);
39771 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39772 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39773 TrustedClosingTransaction_free(this_obj_conv);
39776 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_built_transaction"))) TS_TrustedClosingTransaction_built_transaction(uint64_t this_arg) {
39777 LDKTrustedClosingTransaction this_arg_conv;
39778 this_arg_conv.inner = untag_ptr(this_arg);
39779 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39781 this_arg_conv.is_owned = false;
39782 LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
39783 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39784 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39785 Transaction_free(ret_var);
39789 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) {
39790 LDKTrustedClosingTransaction this_arg_conv;
39791 this_arg_conv.inner = untag_ptr(this_arg);
39792 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39793 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39794 this_arg_conv.is_owned = false;
39795 LDKu8slice funding_redeemscript_ref;
39796 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39797 funding_redeemscript_ref.data = funding_redeemscript->elems;
39798 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39799 memcpy(ret_arr->elems, TrustedClosingTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
39800 FREE(funding_redeemscript);
39804 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) {
39805 LDKTrustedClosingTransaction this_arg_conv;
39806 this_arg_conv.inner = untag_ptr(this_arg);
39807 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39808 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39809 this_arg_conv.is_owned = false;
39810 uint8_t funding_key_arr[32];
39811 CHECK(funding_key->arr_len == 32);
39812 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
39813 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
39814 LDKu8slice funding_redeemscript_ref;
39815 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
39816 funding_redeemscript_ref.data = funding_redeemscript->elems;
39817 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39818 memcpy(ret_arr->elems, TrustedClosingTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
39819 FREE(funding_redeemscript);
39823 void __attribute__((export_name("TS_CommitmentTransaction_free"))) TS_CommitmentTransaction_free(uint64_t this_obj) {
39824 LDKCommitmentTransaction this_obj_conv;
39825 this_obj_conv.inner = untag_ptr(this_obj);
39826 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39828 CommitmentTransaction_free(this_obj_conv);
39831 static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
39832 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
39833 uint64_t ret_ref = 0;
39834 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39835 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39838 int64_t __attribute__((export_name("TS_CommitmentTransaction_clone_ptr"))) TS_CommitmentTransaction_clone_ptr(uint64_t arg) {
39839 LDKCommitmentTransaction arg_conv;
39840 arg_conv.inner = untag_ptr(arg);
39841 arg_conv.is_owned = ptr_is_owned(arg);
39842 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39843 arg_conv.is_owned = false;
39844 int64_t ret_conv = CommitmentTransaction_clone_ptr(&arg_conv);
39848 uint64_t __attribute__((export_name("TS_CommitmentTransaction_clone"))) TS_CommitmentTransaction_clone(uint64_t orig) {
39849 LDKCommitmentTransaction orig_conv;
39850 orig_conv.inner = untag_ptr(orig);
39851 orig_conv.is_owned = ptr_is_owned(orig);
39852 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39853 orig_conv.is_owned = false;
39854 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
39855 uint64_t ret_ref = 0;
39856 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39857 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39861 int8_tArray __attribute__((export_name("TS_CommitmentTransaction_write"))) TS_CommitmentTransaction_write(uint64_t obj) {
39862 LDKCommitmentTransaction obj_conv;
39863 obj_conv.inner = untag_ptr(obj);
39864 obj_conv.is_owned = ptr_is_owned(obj);
39865 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39866 obj_conv.is_owned = false;
39867 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
39868 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39869 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39870 CVec_u8Z_free(ret_var);
39874 uint64_t __attribute__((export_name("TS_CommitmentTransaction_read"))) TS_CommitmentTransaction_read(int8_tArray ser) {
39875 LDKu8slice ser_ref;
39876 ser_ref.datalen = ser->arr_len;
39877 ser_ref.data = ser->elems;
39878 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
39879 *ret_conv = CommitmentTransaction_read(ser_ref);
39881 return tag_ptr(ret_conv, true);
39884 int64_t __attribute__((export_name("TS_CommitmentTransaction_commitment_number"))) TS_CommitmentTransaction_commitment_number(uint64_t this_arg) {
39885 LDKCommitmentTransaction this_arg_conv;
39886 this_arg_conv.inner = untag_ptr(this_arg);
39887 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39888 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39889 this_arg_conv.is_owned = false;
39890 int64_t ret_conv = CommitmentTransaction_commitment_number(&this_arg_conv);
39894 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_broadcaster_value_sat"))) TS_CommitmentTransaction_to_broadcaster_value_sat(uint64_t this_arg) {
39895 LDKCommitmentTransaction this_arg_conv;
39896 this_arg_conv.inner = untag_ptr(this_arg);
39897 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39899 this_arg_conv.is_owned = false;
39900 int64_t ret_conv = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
39904 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_countersignatory_value_sat"))) TS_CommitmentTransaction_to_countersignatory_value_sat(uint64_t this_arg) {
39905 LDKCommitmentTransaction this_arg_conv;
39906 this_arg_conv.inner = untag_ptr(this_arg);
39907 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39908 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39909 this_arg_conv.is_owned = false;
39910 int64_t ret_conv = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
39914 int32_t __attribute__((export_name("TS_CommitmentTransaction_feerate_per_kw"))) TS_CommitmentTransaction_feerate_per_kw(uint64_t this_arg) {
39915 LDKCommitmentTransaction this_arg_conv;
39916 this_arg_conv.inner = untag_ptr(this_arg);
39917 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39919 this_arg_conv.is_owned = false;
39920 int32_t ret_conv = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
39924 uint64_t __attribute__((export_name("TS_CommitmentTransaction_trust"))) TS_CommitmentTransaction_trust(uint64_t this_arg) {
39925 LDKCommitmentTransaction this_arg_conv;
39926 this_arg_conv.inner = untag_ptr(this_arg);
39927 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39929 this_arg_conv.is_owned = false;
39930 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
39931 uint64_t ret_ref = 0;
39932 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39933 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39937 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) {
39938 LDKCommitmentTransaction this_arg_conv;
39939 this_arg_conv.inner = untag_ptr(this_arg);
39940 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39942 this_arg_conv.is_owned = false;
39943 LDKDirectedChannelTransactionParameters channel_parameters_conv;
39944 channel_parameters_conv.inner = untag_ptr(channel_parameters);
39945 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
39946 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
39947 channel_parameters_conv.is_owned = false;
39948 LDKChannelPublicKeys broadcaster_keys_conv;
39949 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
39950 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
39951 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
39952 broadcaster_keys_conv.is_owned = false;
39953 LDKChannelPublicKeys countersignatory_keys_conv;
39954 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
39955 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
39956 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
39957 countersignatory_keys_conv.is_owned = false;
39958 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
39959 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
39960 return tag_ptr(ret_conv, true);
39963 void __attribute__((export_name("TS_TrustedCommitmentTransaction_free"))) TS_TrustedCommitmentTransaction_free(uint64_t this_obj) {
39964 LDKTrustedCommitmentTransaction this_obj_conv;
39965 this_obj_conv.inner = untag_ptr(this_obj);
39966 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39968 TrustedCommitmentTransaction_free(this_obj_conv);
39971 int8_tArray __attribute__((export_name("TS_TrustedCommitmentTransaction_txid"))) TS_TrustedCommitmentTransaction_txid(uint64_t this_arg) {
39972 LDKTrustedCommitmentTransaction this_arg_conv;
39973 this_arg_conv.inner = untag_ptr(this_arg);
39974 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39975 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39976 this_arg_conv.is_owned = false;
39977 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39978 memcpy(ret_arr->elems, TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
39982 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_built_transaction"))) TS_TrustedCommitmentTransaction_built_transaction(uint64_t this_arg) {
39983 LDKTrustedCommitmentTransaction this_arg_conv;
39984 this_arg_conv.inner = untag_ptr(this_arg);
39985 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39986 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39987 this_arg_conv.is_owned = false;
39988 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
39989 uint64_t ret_ref = 0;
39990 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39991 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39995 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_keys"))) TS_TrustedCommitmentTransaction_keys(uint64_t this_arg) {
39996 LDKTrustedCommitmentTransaction this_arg_conv;
39997 this_arg_conv.inner = untag_ptr(this_arg);
39998 this_arg_conv.is_owned = ptr_is_owned(this_arg);
39999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40000 this_arg_conv.is_owned = false;
40001 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
40002 uint64_t ret_ref = 0;
40003 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40004 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40008 jboolean __attribute__((export_name("TS_TrustedCommitmentTransaction_opt_anchors"))) TS_TrustedCommitmentTransaction_opt_anchors(uint64_t this_arg) {
40009 LDKTrustedCommitmentTransaction this_arg_conv;
40010 this_arg_conv.inner = untag_ptr(this_arg);
40011 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40013 this_arg_conv.is_owned = false;
40014 jboolean ret_conv = TrustedCommitmentTransaction_opt_anchors(&this_arg_conv);
40018 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) {
40019 LDKTrustedCommitmentTransaction this_arg_conv;
40020 this_arg_conv.inner = untag_ptr(this_arg);
40021 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40023 this_arg_conv.is_owned = false;
40024 uint8_t htlc_base_key_arr[32];
40025 CHECK(htlc_base_key->arr_len == 32);
40026 memcpy(htlc_base_key_arr, htlc_base_key->elems, 32); FREE(htlc_base_key);
40027 uint8_t (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
40028 LDKDirectedChannelTransactionParameters channel_parameters_conv;
40029 channel_parameters_conv.inner = untag_ptr(channel_parameters);
40030 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
40031 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
40032 channel_parameters_conv.is_owned = false;
40033 void* entropy_source_ptr = untag_ptr(entropy_source);
40034 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
40035 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
40036 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
40037 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv, entropy_source_conv);
40038 return tag_ptr(ret_conv, true);
40041 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) {
40042 LDKPublicKey broadcaster_payment_basepoint_ref;
40043 CHECK(broadcaster_payment_basepoint->arr_len == 33);
40044 memcpy(broadcaster_payment_basepoint_ref.compressed_form, broadcaster_payment_basepoint->elems, 33); FREE(broadcaster_payment_basepoint);
40045 LDKPublicKey countersignatory_payment_basepoint_ref;
40046 CHECK(countersignatory_payment_basepoint->arr_len == 33);
40047 memcpy(countersignatory_payment_basepoint_ref.compressed_form, countersignatory_payment_basepoint->elems, 33); FREE(countersignatory_payment_basepoint);
40048 int64_t ret_conv = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
40052 jboolean __attribute__((export_name("TS_InitFeatures_eq"))) TS_InitFeatures_eq(uint64_t a, uint64_t b) {
40053 LDKInitFeatures a_conv;
40054 a_conv.inner = untag_ptr(a);
40055 a_conv.is_owned = ptr_is_owned(a);
40056 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40057 a_conv.is_owned = false;
40058 LDKInitFeatures b_conv;
40059 b_conv.inner = untag_ptr(b);
40060 b_conv.is_owned = ptr_is_owned(b);
40061 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40062 b_conv.is_owned = false;
40063 jboolean ret_conv = InitFeatures_eq(&a_conv, &b_conv);
40067 jboolean __attribute__((export_name("TS_NodeFeatures_eq"))) TS_NodeFeatures_eq(uint64_t a, uint64_t b) {
40068 LDKNodeFeatures a_conv;
40069 a_conv.inner = untag_ptr(a);
40070 a_conv.is_owned = ptr_is_owned(a);
40071 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40072 a_conv.is_owned = false;
40073 LDKNodeFeatures b_conv;
40074 b_conv.inner = untag_ptr(b);
40075 b_conv.is_owned = ptr_is_owned(b);
40076 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40077 b_conv.is_owned = false;
40078 jboolean ret_conv = NodeFeatures_eq(&a_conv, &b_conv);
40082 jboolean __attribute__((export_name("TS_ChannelFeatures_eq"))) TS_ChannelFeatures_eq(uint64_t a, uint64_t b) {
40083 LDKChannelFeatures a_conv;
40084 a_conv.inner = untag_ptr(a);
40085 a_conv.is_owned = ptr_is_owned(a);
40086 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40087 a_conv.is_owned = false;
40088 LDKChannelFeatures b_conv;
40089 b_conv.inner = untag_ptr(b);
40090 b_conv.is_owned = ptr_is_owned(b);
40091 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40092 b_conv.is_owned = false;
40093 jboolean ret_conv = ChannelFeatures_eq(&a_conv, &b_conv);
40097 jboolean __attribute__((export_name("TS_InvoiceFeatures_eq"))) TS_InvoiceFeatures_eq(uint64_t a, uint64_t b) {
40098 LDKInvoiceFeatures a_conv;
40099 a_conv.inner = untag_ptr(a);
40100 a_conv.is_owned = ptr_is_owned(a);
40101 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40102 a_conv.is_owned = false;
40103 LDKInvoiceFeatures b_conv;
40104 b_conv.inner = untag_ptr(b);
40105 b_conv.is_owned = ptr_is_owned(b);
40106 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40107 b_conv.is_owned = false;
40108 jboolean ret_conv = InvoiceFeatures_eq(&a_conv, &b_conv);
40112 jboolean __attribute__((export_name("TS_OfferFeatures_eq"))) TS_OfferFeatures_eq(uint64_t a, uint64_t b) {
40113 LDKOfferFeatures a_conv;
40114 a_conv.inner = untag_ptr(a);
40115 a_conv.is_owned = ptr_is_owned(a);
40116 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40117 a_conv.is_owned = false;
40118 LDKOfferFeatures b_conv;
40119 b_conv.inner = untag_ptr(b);
40120 b_conv.is_owned = ptr_is_owned(b);
40121 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40122 b_conv.is_owned = false;
40123 jboolean ret_conv = OfferFeatures_eq(&a_conv, &b_conv);
40127 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_eq"))) TS_InvoiceRequestFeatures_eq(uint64_t a, uint64_t b) {
40128 LDKInvoiceRequestFeatures a_conv;
40129 a_conv.inner = untag_ptr(a);
40130 a_conv.is_owned = ptr_is_owned(a);
40131 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40132 a_conv.is_owned = false;
40133 LDKInvoiceRequestFeatures b_conv;
40134 b_conv.inner = untag_ptr(b);
40135 b_conv.is_owned = ptr_is_owned(b);
40136 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40137 b_conv.is_owned = false;
40138 jboolean ret_conv = InvoiceRequestFeatures_eq(&a_conv, &b_conv);
40142 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_eq"))) TS_Bolt12InvoiceFeatures_eq(uint64_t a, uint64_t b) {
40143 LDKBolt12InvoiceFeatures a_conv;
40144 a_conv.inner = untag_ptr(a);
40145 a_conv.is_owned = ptr_is_owned(a);
40146 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40147 a_conv.is_owned = false;
40148 LDKBolt12InvoiceFeatures b_conv;
40149 b_conv.inner = untag_ptr(b);
40150 b_conv.is_owned = ptr_is_owned(b);
40151 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40152 b_conv.is_owned = false;
40153 jboolean ret_conv = Bolt12InvoiceFeatures_eq(&a_conv, &b_conv);
40157 jboolean __attribute__((export_name("TS_BlindedHopFeatures_eq"))) TS_BlindedHopFeatures_eq(uint64_t a, uint64_t b) {
40158 LDKBlindedHopFeatures a_conv;
40159 a_conv.inner = untag_ptr(a);
40160 a_conv.is_owned = ptr_is_owned(a);
40161 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40162 a_conv.is_owned = false;
40163 LDKBlindedHopFeatures b_conv;
40164 b_conv.inner = untag_ptr(b);
40165 b_conv.is_owned = ptr_is_owned(b);
40166 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40167 b_conv.is_owned = false;
40168 jboolean ret_conv = BlindedHopFeatures_eq(&a_conv, &b_conv);
40172 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_eq"))) TS_ChannelTypeFeatures_eq(uint64_t a, uint64_t b) {
40173 LDKChannelTypeFeatures a_conv;
40174 a_conv.inner = untag_ptr(a);
40175 a_conv.is_owned = ptr_is_owned(a);
40176 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40177 a_conv.is_owned = false;
40178 LDKChannelTypeFeatures b_conv;
40179 b_conv.inner = untag_ptr(b);
40180 b_conv.is_owned = ptr_is_owned(b);
40181 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40182 b_conv.is_owned = false;
40183 jboolean ret_conv = ChannelTypeFeatures_eq(&a_conv, &b_conv);
40187 static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
40188 LDKInitFeatures ret_var = InitFeatures_clone(arg);
40189 uint64_t ret_ref = 0;
40190 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40191 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40194 int64_t __attribute__((export_name("TS_InitFeatures_clone_ptr"))) TS_InitFeatures_clone_ptr(uint64_t arg) {
40195 LDKInitFeatures arg_conv;
40196 arg_conv.inner = untag_ptr(arg);
40197 arg_conv.is_owned = ptr_is_owned(arg);
40198 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40199 arg_conv.is_owned = false;
40200 int64_t ret_conv = InitFeatures_clone_ptr(&arg_conv);
40204 uint64_t __attribute__((export_name("TS_InitFeatures_clone"))) TS_InitFeatures_clone(uint64_t orig) {
40205 LDKInitFeatures orig_conv;
40206 orig_conv.inner = untag_ptr(orig);
40207 orig_conv.is_owned = ptr_is_owned(orig);
40208 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40209 orig_conv.is_owned = false;
40210 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
40211 uint64_t ret_ref = 0;
40212 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40213 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40217 static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
40218 LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
40219 uint64_t ret_ref = 0;
40220 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40221 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40224 int64_t __attribute__((export_name("TS_NodeFeatures_clone_ptr"))) TS_NodeFeatures_clone_ptr(uint64_t arg) {
40225 LDKNodeFeatures arg_conv;
40226 arg_conv.inner = untag_ptr(arg);
40227 arg_conv.is_owned = ptr_is_owned(arg);
40228 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40229 arg_conv.is_owned = false;
40230 int64_t ret_conv = NodeFeatures_clone_ptr(&arg_conv);
40234 uint64_t __attribute__((export_name("TS_NodeFeatures_clone"))) TS_NodeFeatures_clone(uint64_t orig) {
40235 LDKNodeFeatures orig_conv;
40236 orig_conv.inner = untag_ptr(orig);
40237 orig_conv.is_owned = ptr_is_owned(orig);
40238 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40239 orig_conv.is_owned = false;
40240 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
40241 uint64_t ret_ref = 0;
40242 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40243 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40247 static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
40248 LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
40249 uint64_t ret_ref = 0;
40250 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40251 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40254 int64_t __attribute__((export_name("TS_ChannelFeatures_clone_ptr"))) TS_ChannelFeatures_clone_ptr(uint64_t arg) {
40255 LDKChannelFeatures arg_conv;
40256 arg_conv.inner = untag_ptr(arg);
40257 arg_conv.is_owned = ptr_is_owned(arg);
40258 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40259 arg_conv.is_owned = false;
40260 int64_t ret_conv = ChannelFeatures_clone_ptr(&arg_conv);
40264 uint64_t __attribute__((export_name("TS_ChannelFeatures_clone"))) TS_ChannelFeatures_clone(uint64_t orig) {
40265 LDKChannelFeatures orig_conv;
40266 orig_conv.inner = untag_ptr(orig);
40267 orig_conv.is_owned = ptr_is_owned(orig);
40268 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40269 orig_conv.is_owned = false;
40270 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
40271 uint64_t ret_ref = 0;
40272 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40273 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40277 static inline uint64_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
40278 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
40279 uint64_t ret_ref = 0;
40280 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40281 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40284 int64_t __attribute__((export_name("TS_InvoiceFeatures_clone_ptr"))) TS_InvoiceFeatures_clone_ptr(uint64_t arg) {
40285 LDKInvoiceFeatures arg_conv;
40286 arg_conv.inner = untag_ptr(arg);
40287 arg_conv.is_owned = ptr_is_owned(arg);
40288 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40289 arg_conv.is_owned = false;
40290 int64_t ret_conv = InvoiceFeatures_clone_ptr(&arg_conv);
40294 uint64_t __attribute__((export_name("TS_InvoiceFeatures_clone"))) TS_InvoiceFeatures_clone(uint64_t orig) {
40295 LDKInvoiceFeatures orig_conv;
40296 orig_conv.inner = untag_ptr(orig);
40297 orig_conv.is_owned = ptr_is_owned(orig);
40298 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40299 orig_conv.is_owned = false;
40300 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
40301 uint64_t ret_ref = 0;
40302 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40303 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40307 static inline uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg) {
40308 LDKOfferFeatures ret_var = OfferFeatures_clone(arg);
40309 uint64_t ret_ref = 0;
40310 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40311 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40314 int64_t __attribute__((export_name("TS_OfferFeatures_clone_ptr"))) TS_OfferFeatures_clone_ptr(uint64_t arg) {
40315 LDKOfferFeatures arg_conv;
40316 arg_conv.inner = untag_ptr(arg);
40317 arg_conv.is_owned = ptr_is_owned(arg);
40318 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40319 arg_conv.is_owned = false;
40320 int64_t ret_conv = OfferFeatures_clone_ptr(&arg_conv);
40324 uint64_t __attribute__((export_name("TS_OfferFeatures_clone"))) TS_OfferFeatures_clone(uint64_t orig) {
40325 LDKOfferFeatures orig_conv;
40326 orig_conv.inner = untag_ptr(orig);
40327 orig_conv.is_owned = ptr_is_owned(orig);
40328 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40329 orig_conv.is_owned = false;
40330 LDKOfferFeatures ret_var = OfferFeatures_clone(&orig_conv);
40331 uint64_t ret_ref = 0;
40332 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40333 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40337 static inline uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg) {
40338 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(arg);
40339 uint64_t ret_ref = 0;
40340 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40341 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40344 int64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone_ptr"))) TS_InvoiceRequestFeatures_clone_ptr(uint64_t arg) {
40345 LDKInvoiceRequestFeatures arg_conv;
40346 arg_conv.inner = untag_ptr(arg);
40347 arg_conv.is_owned = ptr_is_owned(arg);
40348 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40349 arg_conv.is_owned = false;
40350 int64_t ret_conv = InvoiceRequestFeatures_clone_ptr(&arg_conv);
40354 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone"))) TS_InvoiceRequestFeatures_clone(uint64_t orig) {
40355 LDKInvoiceRequestFeatures orig_conv;
40356 orig_conv.inner = untag_ptr(orig);
40357 orig_conv.is_owned = ptr_is_owned(orig);
40358 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40359 orig_conv.is_owned = false;
40360 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(&orig_conv);
40361 uint64_t ret_ref = 0;
40362 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40363 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40367 static inline uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg) {
40368 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_clone(arg);
40369 uint64_t ret_ref = 0;
40370 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40371 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40374 int64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_clone_ptr"))) TS_Bolt12InvoiceFeatures_clone_ptr(uint64_t arg) {
40375 LDKBolt12InvoiceFeatures arg_conv;
40376 arg_conv.inner = untag_ptr(arg);
40377 arg_conv.is_owned = ptr_is_owned(arg);
40378 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40379 arg_conv.is_owned = false;
40380 int64_t ret_conv = Bolt12InvoiceFeatures_clone_ptr(&arg_conv);
40384 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_clone"))) TS_Bolt12InvoiceFeatures_clone(uint64_t orig) {
40385 LDKBolt12InvoiceFeatures orig_conv;
40386 orig_conv.inner = untag_ptr(orig);
40387 orig_conv.is_owned = ptr_is_owned(orig);
40388 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40389 orig_conv.is_owned = false;
40390 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_clone(&orig_conv);
40391 uint64_t ret_ref = 0;
40392 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40393 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40397 static inline uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg) {
40398 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_clone(arg);
40399 uint64_t ret_ref = 0;
40400 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40401 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40404 int64_t __attribute__((export_name("TS_BlindedHopFeatures_clone_ptr"))) TS_BlindedHopFeatures_clone_ptr(uint64_t arg) {
40405 LDKBlindedHopFeatures arg_conv;
40406 arg_conv.inner = untag_ptr(arg);
40407 arg_conv.is_owned = ptr_is_owned(arg);
40408 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40409 arg_conv.is_owned = false;
40410 int64_t ret_conv = BlindedHopFeatures_clone_ptr(&arg_conv);
40414 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_clone"))) TS_BlindedHopFeatures_clone(uint64_t orig) {
40415 LDKBlindedHopFeatures orig_conv;
40416 orig_conv.inner = untag_ptr(orig);
40417 orig_conv.is_owned = ptr_is_owned(orig);
40418 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40419 orig_conv.is_owned = false;
40420 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_clone(&orig_conv);
40421 uint64_t ret_ref = 0;
40422 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40423 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40427 static inline uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg) {
40428 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(arg);
40429 uint64_t ret_ref = 0;
40430 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40431 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40434 int64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone_ptr"))) TS_ChannelTypeFeatures_clone_ptr(uint64_t arg) {
40435 LDKChannelTypeFeatures arg_conv;
40436 arg_conv.inner = untag_ptr(arg);
40437 arg_conv.is_owned = ptr_is_owned(arg);
40438 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40439 arg_conv.is_owned = false;
40440 int64_t ret_conv = ChannelTypeFeatures_clone_ptr(&arg_conv);
40444 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone"))) TS_ChannelTypeFeatures_clone(uint64_t orig) {
40445 LDKChannelTypeFeatures orig_conv;
40446 orig_conv.inner = untag_ptr(orig);
40447 orig_conv.is_owned = ptr_is_owned(orig);
40448 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40449 orig_conv.is_owned = false;
40450 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(&orig_conv);
40451 uint64_t ret_ref = 0;
40452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40453 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40457 void __attribute__((export_name("TS_InitFeatures_free"))) TS_InitFeatures_free(uint64_t this_obj) {
40458 LDKInitFeatures this_obj_conv;
40459 this_obj_conv.inner = untag_ptr(this_obj);
40460 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40461 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40462 InitFeatures_free(this_obj_conv);
40465 void __attribute__((export_name("TS_NodeFeatures_free"))) TS_NodeFeatures_free(uint64_t this_obj) {
40466 LDKNodeFeatures this_obj_conv;
40467 this_obj_conv.inner = untag_ptr(this_obj);
40468 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40469 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40470 NodeFeatures_free(this_obj_conv);
40473 void __attribute__((export_name("TS_ChannelFeatures_free"))) TS_ChannelFeatures_free(uint64_t this_obj) {
40474 LDKChannelFeatures this_obj_conv;
40475 this_obj_conv.inner = untag_ptr(this_obj);
40476 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40478 ChannelFeatures_free(this_obj_conv);
40481 void __attribute__((export_name("TS_InvoiceFeatures_free"))) TS_InvoiceFeatures_free(uint64_t this_obj) {
40482 LDKInvoiceFeatures this_obj_conv;
40483 this_obj_conv.inner = untag_ptr(this_obj);
40484 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40485 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40486 InvoiceFeatures_free(this_obj_conv);
40489 void __attribute__((export_name("TS_OfferFeatures_free"))) TS_OfferFeatures_free(uint64_t this_obj) {
40490 LDKOfferFeatures this_obj_conv;
40491 this_obj_conv.inner = untag_ptr(this_obj);
40492 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40494 OfferFeatures_free(this_obj_conv);
40497 void __attribute__((export_name("TS_InvoiceRequestFeatures_free"))) TS_InvoiceRequestFeatures_free(uint64_t this_obj) {
40498 LDKInvoiceRequestFeatures this_obj_conv;
40499 this_obj_conv.inner = untag_ptr(this_obj);
40500 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40501 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40502 InvoiceRequestFeatures_free(this_obj_conv);
40505 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_free"))) TS_Bolt12InvoiceFeatures_free(uint64_t this_obj) {
40506 LDKBolt12InvoiceFeatures this_obj_conv;
40507 this_obj_conv.inner = untag_ptr(this_obj);
40508 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40510 Bolt12InvoiceFeatures_free(this_obj_conv);
40513 void __attribute__((export_name("TS_BlindedHopFeatures_free"))) TS_BlindedHopFeatures_free(uint64_t this_obj) {
40514 LDKBlindedHopFeatures this_obj_conv;
40515 this_obj_conv.inner = untag_ptr(this_obj);
40516 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40518 BlindedHopFeatures_free(this_obj_conv);
40521 void __attribute__((export_name("TS_ChannelTypeFeatures_free"))) TS_ChannelTypeFeatures_free(uint64_t this_obj) {
40522 LDKChannelTypeFeatures this_obj_conv;
40523 this_obj_conv.inner = untag_ptr(this_obj);
40524 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40526 ChannelTypeFeatures_free(this_obj_conv);
40529 uint64_t __attribute__((export_name("TS_InitFeatures_empty"))) TS_InitFeatures_empty() {
40530 LDKInitFeatures ret_var = InitFeatures_empty();
40531 uint64_t ret_ref = 0;
40532 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40533 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40537 jboolean __attribute__((export_name("TS_InitFeatures_requires_unknown_bits"))) TS_InitFeatures_requires_unknown_bits(uint64_t this_arg) {
40538 LDKInitFeatures this_arg_conv;
40539 this_arg_conv.inner = untag_ptr(this_arg);
40540 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40542 this_arg_conv.is_owned = false;
40543 jboolean ret_conv = InitFeatures_requires_unknown_bits(&this_arg_conv);
40547 uint64_t __attribute__((export_name("TS_NodeFeatures_empty"))) TS_NodeFeatures_empty() {
40548 LDKNodeFeatures ret_var = NodeFeatures_empty();
40549 uint64_t ret_ref = 0;
40550 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40551 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40555 jboolean __attribute__((export_name("TS_NodeFeatures_requires_unknown_bits"))) TS_NodeFeatures_requires_unknown_bits(uint64_t this_arg) {
40556 LDKNodeFeatures this_arg_conv;
40557 this_arg_conv.inner = untag_ptr(this_arg);
40558 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40560 this_arg_conv.is_owned = false;
40561 jboolean ret_conv = NodeFeatures_requires_unknown_bits(&this_arg_conv);
40565 uint64_t __attribute__((export_name("TS_ChannelFeatures_empty"))) TS_ChannelFeatures_empty() {
40566 LDKChannelFeatures ret_var = ChannelFeatures_empty();
40567 uint64_t ret_ref = 0;
40568 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40569 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40573 jboolean __attribute__((export_name("TS_ChannelFeatures_requires_unknown_bits"))) TS_ChannelFeatures_requires_unknown_bits(uint64_t this_arg) {
40574 LDKChannelFeatures this_arg_conv;
40575 this_arg_conv.inner = untag_ptr(this_arg);
40576 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40577 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40578 this_arg_conv.is_owned = false;
40579 jboolean ret_conv = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
40583 uint64_t __attribute__((export_name("TS_InvoiceFeatures_empty"))) TS_InvoiceFeatures_empty() {
40584 LDKInvoiceFeatures ret_var = InvoiceFeatures_empty();
40585 uint64_t ret_ref = 0;
40586 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40587 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40591 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_unknown_bits"))) TS_InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
40592 LDKInvoiceFeatures this_arg_conv;
40593 this_arg_conv.inner = untag_ptr(this_arg);
40594 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40596 this_arg_conv.is_owned = false;
40597 jboolean ret_conv = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
40601 uint64_t __attribute__((export_name("TS_OfferFeatures_empty"))) TS_OfferFeatures_empty() {
40602 LDKOfferFeatures ret_var = OfferFeatures_empty();
40603 uint64_t ret_ref = 0;
40604 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40605 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40609 jboolean __attribute__((export_name("TS_OfferFeatures_requires_unknown_bits"))) TS_OfferFeatures_requires_unknown_bits(uint64_t this_arg) {
40610 LDKOfferFeatures this_arg_conv;
40611 this_arg_conv.inner = untag_ptr(this_arg);
40612 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40614 this_arg_conv.is_owned = false;
40615 jboolean ret_conv = OfferFeatures_requires_unknown_bits(&this_arg_conv);
40619 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_empty"))) TS_InvoiceRequestFeatures_empty() {
40620 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_empty();
40621 uint64_t ret_ref = 0;
40622 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40623 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40627 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_requires_unknown_bits"))) TS_InvoiceRequestFeatures_requires_unknown_bits(uint64_t this_arg) {
40628 LDKInvoiceRequestFeatures this_arg_conv;
40629 this_arg_conv.inner = untag_ptr(this_arg);
40630 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40632 this_arg_conv.is_owned = false;
40633 jboolean ret_conv = InvoiceRequestFeatures_requires_unknown_bits(&this_arg_conv);
40637 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_empty"))) TS_Bolt12InvoiceFeatures_empty() {
40638 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_empty();
40639 uint64_t ret_ref = 0;
40640 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40641 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40645 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_unknown_bits"))) TS_Bolt12InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
40646 LDKBolt12InvoiceFeatures this_arg_conv;
40647 this_arg_conv.inner = untag_ptr(this_arg);
40648 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40650 this_arg_conv.is_owned = false;
40651 jboolean ret_conv = Bolt12InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
40655 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_empty"))) TS_BlindedHopFeatures_empty() {
40656 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_empty();
40657 uint64_t ret_ref = 0;
40658 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40659 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40663 jboolean __attribute__((export_name("TS_BlindedHopFeatures_requires_unknown_bits"))) TS_BlindedHopFeatures_requires_unknown_bits(uint64_t this_arg) {
40664 LDKBlindedHopFeatures this_arg_conv;
40665 this_arg_conv.inner = untag_ptr(this_arg);
40666 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40668 this_arg_conv.is_owned = false;
40669 jboolean ret_conv = BlindedHopFeatures_requires_unknown_bits(&this_arg_conv);
40673 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_empty"))) TS_ChannelTypeFeatures_empty() {
40674 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_empty();
40675 uint64_t ret_ref = 0;
40676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40677 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40681 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_unknown_bits"))) TS_ChannelTypeFeatures_requires_unknown_bits(uint64_t this_arg) {
40682 LDKChannelTypeFeatures this_arg_conv;
40683 this_arg_conv.inner = untag_ptr(this_arg);
40684 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40686 this_arg_conv.is_owned = false;
40687 jboolean ret_conv = ChannelTypeFeatures_requires_unknown_bits(&this_arg_conv);
40691 int8_tArray __attribute__((export_name("TS_InitFeatures_write"))) TS_InitFeatures_write(uint64_t obj) {
40692 LDKInitFeatures obj_conv;
40693 obj_conv.inner = untag_ptr(obj);
40694 obj_conv.is_owned = ptr_is_owned(obj);
40695 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40696 obj_conv.is_owned = false;
40697 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
40698 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40699 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40700 CVec_u8Z_free(ret_var);
40704 uint64_t __attribute__((export_name("TS_InitFeatures_read"))) TS_InitFeatures_read(int8_tArray ser) {
40705 LDKu8slice ser_ref;
40706 ser_ref.datalen = ser->arr_len;
40707 ser_ref.data = ser->elems;
40708 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
40709 *ret_conv = InitFeatures_read(ser_ref);
40711 return tag_ptr(ret_conv, true);
40714 int8_tArray __attribute__((export_name("TS_ChannelFeatures_write"))) TS_ChannelFeatures_write(uint64_t obj) {
40715 LDKChannelFeatures obj_conv;
40716 obj_conv.inner = untag_ptr(obj);
40717 obj_conv.is_owned = ptr_is_owned(obj);
40718 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40719 obj_conv.is_owned = false;
40720 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
40721 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40722 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40723 CVec_u8Z_free(ret_var);
40727 uint64_t __attribute__((export_name("TS_ChannelFeatures_read"))) TS_ChannelFeatures_read(int8_tArray ser) {
40728 LDKu8slice ser_ref;
40729 ser_ref.datalen = ser->arr_len;
40730 ser_ref.data = ser->elems;
40731 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
40732 *ret_conv = ChannelFeatures_read(ser_ref);
40734 return tag_ptr(ret_conv, true);
40737 int8_tArray __attribute__((export_name("TS_NodeFeatures_write"))) TS_NodeFeatures_write(uint64_t obj) {
40738 LDKNodeFeatures obj_conv;
40739 obj_conv.inner = untag_ptr(obj);
40740 obj_conv.is_owned = ptr_is_owned(obj);
40741 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40742 obj_conv.is_owned = false;
40743 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
40744 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40745 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40746 CVec_u8Z_free(ret_var);
40750 uint64_t __attribute__((export_name("TS_NodeFeatures_read"))) TS_NodeFeatures_read(int8_tArray ser) {
40751 LDKu8slice ser_ref;
40752 ser_ref.datalen = ser->arr_len;
40753 ser_ref.data = ser->elems;
40754 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
40755 *ret_conv = NodeFeatures_read(ser_ref);
40757 return tag_ptr(ret_conv, true);
40760 int8_tArray __attribute__((export_name("TS_InvoiceFeatures_write"))) TS_InvoiceFeatures_write(uint64_t obj) {
40761 LDKInvoiceFeatures obj_conv;
40762 obj_conv.inner = untag_ptr(obj);
40763 obj_conv.is_owned = ptr_is_owned(obj);
40764 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40765 obj_conv.is_owned = false;
40766 LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
40767 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40768 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40769 CVec_u8Z_free(ret_var);
40773 uint64_t __attribute__((export_name("TS_InvoiceFeatures_read"))) TS_InvoiceFeatures_read(int8_tArray ser) {
40774 LDKu8slice ser_ref;
40775 ser_ref.datalen = ser->arr_len;
40776 ser_ref.data = ser->elems;
40777 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
40778 *ret_conv = InvoiceFeatures_read(ser_ref);
40780 return tag_ptr(ret_conv, true);
40783 int8_tArray __attribute__((export_name("TS_BlindedHopFeatures_write"))) TS_BlindedHopFeatures_write(uint64_t obj) {
40784 LDKBlindedHopFeatures obj_conv;
40785 obj_conv.inner = untag_ptr(obj);
40786 obj_conv.is_owned = ptr_is_owned(obj);
40787 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40788 obj_conv.is_owned = false;
40789 LDKCVec_u8Z ret_var = BlindedHopFeatures_write(&obj_conv);
40790 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40791 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40792 CVec_u8Z_free(ret_var);
40796 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_read"))) TS_BlindedHopFeatures_read(int8_tArray ser) {
40797 LDKu8slice ser_ref;
40798 ser_ref.datalen = ser->arr_len;
40799 ser_ref.data = ser->elems;
40800 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
40801 *ret_conv = BlindedHopFeatures_read(ser_ref);
40803 return tag_ptr(ret_conv, true);
40806 int8_tArray __attribute__((export_name("TS_ChannelTypeFeatures_write"))) TS_ChannelTypeFeatures_write(uint64_t obj) {
40807 LDKChannelTypeFeatures obj_conv;
40808 obj_conv.inner = untag_ptr(obj);
40809 obj_conv.is_owned = ptr_is_owned(obj);
40810 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40811 obj_conv.is_owned = false;
40812 LDKCVec_u8Z ret_var = ChannelTypeFeatures_write(&obj_conv);
40813 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40814 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40815 CVec_u8Z_free(ret_var);
40819 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_read"))) TS_ChannelTypeFeatures_read(int8_tArray ser) {
40820 LDKu8slice ser_ref;
40821 ser_ref.datalen = ser->arr_len;
40822 ser_ref.data = ser->elems;
40823 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
40824 *ret_conv = ChannelTypeFeatures_read(ser_ref);
40826 return tag_ptr(ret_conv, true);
40829 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_optional"))) TS_InitFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
40830 LDKInitFeatures this_arg_conv;
40831 this_arg_conv.inner = untag_ptr(this_arg);
40832 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40834 this_arg_conv.is_owned = false;
40835 InitFeatures_set_data_loss_protect_optional(&this_arg_conv);
40838 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_required"))) TS_InitFeatures_set_data_loss_protect_required(uint64_t this_arg) {
40839 LDKInitFeatures this_arg_conv;
40840 this_arg_conv.inner = untag_ptr(this_arg);
40841 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40843 this_arg_conv.is_owned = false;
40844 InitFeatures_set_data_loss_protect_required(&this_arg_conv);
40847 jboolean __attribute__((export_name("TS_InitFeatures_supports_data_loss_protect"))) TS_InitFeatures_supports_data_loss_protect(uint64_t this_arg) {
40848 LDKInitFeatures this_arg_conv;
40849 this_arg_conv.inner = untag_ptr(this_arg);
40850 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40852 this_arg_conv.is_owned = false;
40853 jboolean ret_conv = InitFeatures_supports_data_loss_protect(&this_arg_conv);
40857 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_optional"))) TS_NodeFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
40858 LDKNodeFeatures this_arg_conv;
40859 this_arg_conv.inner = untag_ptr(this_arg);
40860 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40862 this_arg_conv.is_owned = false;
40863 NodeFeatures_set_data_loss_protect_optional(&this_arg_conv);
40866 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_required"))) TS_NodeFeatures_set_data_loss_protect_required(uint64_t this_arg) {
40867 LDKNodeFeatures this_arg_conv;
40868 this_arg_conv.inner = untag_ptr(this_arg);
40869 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40871 this_arg_conv.is_owned = false;
40872 NodeFeatures_set_data_loss_protect_required(&this_arg_conv);
40875 jboolean __attribute__((export_name("TS_NodeFeatures_supports_data_loss_protect"))) TS_NodeFeatures_supports_data_loss_protect(uint64_t this_arg) {
40876 LDKNodeFeatures this_arg_conv;
40877 this_arg_conv.inner = untag_ptr(this_arg);
40878 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40879 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40880 this_arg_conv.is_owned = false;
40881 jboolean ret_conv = NodeFeatures_supports_data_loss_protect(&this_arg_conv);
40885 jboolean __attribute__((export_name("TS_InitFeatures_requires_data_loss_protect"))) TS_InitFeatures_requires_data_loss_protect(uint64_t this_arg) {
40886 LDKInitFeatures this_arg_conv;
40887 this_arg_conv.inner = untag_ptr(this_arg);
40888 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40889 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40890 this_arg_conv.is_owned = false;
40891 jboolean ret_conv = InitFeatures_requires_data_loss_protect(&this_arg_conv);
40895 jboolean __attribute__((export_name("TS_NodeFeatures_requires_data_loss_protect"))) TS_NodeFeatures_requires_data_loss_protect(uint64_t this_arg) {
40896 LDKNodeFeatures this_arg_conv;
40897 this_arg_conv.inner = untag_ptr(this_arg);
40898 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40900 this_arg_conv.is_owned = false;
40901 jboolean ret_conv = NodeFeatures_requires_data_loss_protect(&this_arg_conv);
40905 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_optional"))) TS_InitFeatures_set_initial_routing_sync_optional(uint64_t this_arg) {
40906 LDKInitFeatures this_arg_conv;
40907 this_arg_conv.inner = untag_ptr(this_arg);
40908 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40910 this_arg_conv.is_owned = false;
40911 InitFeatures_set_initial_routing_sync_optional(&this_arg_conv);
40914 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_required"))) TS_InitFeatures_set_initial_routing_sync_required(uint64_t this_arg) {
40915 LDKInitFeatures this_arg_conv;
40916 this_arg_conv.inner = untag_ptr(this_arg);
40917 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40919 this_arg_conv.is_owned = false;
40920 InitFeatures_set_initial_routing_sync_required(&this_arg_conv);
40923 jboolean __attribute__((export_name("TS_InitFeatures_initial_routing_sync"))) TS_InitFeatures_initial_routing_sync(uint64_t this_arg) {
40924 LDKInitFeatures this_arg_conv;
40925 this_arg_conv.inner = untag_ptr(this_arg);
40926 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40928 this_arg_conv.is_owned = false;
40929 jboolean ret_conv = InitFeatures_initial_routing_sync(&this_arg_conv);
40933 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_optional"))) TS_InitFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
40934 LDKInitFeatures this_arg_conv;
40935 this_arg_conv.inner = untag_ptr(this_arg);
40936 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40938 this_arg_conv.is_owned = false;
40939 InitFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
40942 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_required"))) TS_InitFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
40943 LDKInitFeatures this_arg_conv;
40944 this_arg_conv.inner = untag_ptr(this_arg);
40945 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40947 this_arg_conv.is_owned = false;
40948 InitFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
40951 jboolean __attribute__((export_name("TS_InitFeatures_supports_upfront_shutdown_script"))) TS_InitFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
40952 LDKInitFeatures this_arg_conv;
40953 this_arg_conv.inner = untag_ptr(this_arg);
40954 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40956 this_arg_conv.is_owned = false;
40957 jboolean ret_conv = InitFeatures_supports_upfront_shutdown_script(&this_arg_conv);
40961 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_optional"))) TS_NodeFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
40962 LDKNodeFeatures this_arg_conv;
40963 this_arg_conv.inner = untag_ptr(this_arg);
40964 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40966 this_arg_conv.is_owned = false;
40967 NodeFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
40970 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_required"))) TS_NodeFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
40971 LDKNodeFeatures this_arg_conv;
40972 this_arg_conv.inner = untag_ptr(this_arg);
40973 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40974 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40975 this_arg_conv.is_owned = false;
40976 NodeFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
40979 jboolean __attribute__((export_name("TS_NodeFeatures_supports_upfront_shutdown_script"))) TS_NodeFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
40980 LDKNodeFeatures this_arg_conv;
40981 this_arg_conv.inner = untag_ptr(this_arg);
40982 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40984 this_arg_conv.is_owned = false;
40985 jboolean ret_conv = NodeFeatures_supports_upfront_shutdown_script(&this_arg_conv);
40989 jboolean __attribute__((export_name("TS_InitFeatures_requires_upfront_shutdown_script"))) TS_InitFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
40990 LDKInitFeatures this_arg_conv;
40991 this_arg_conv.inner = untag_ptr(this_arg);
40992 this_arg_conv.is_owned = ptr_is_owned(this_arg);
40993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40994 this_arg_conv.is_owned = false;
40995 jboolean ret_conv = InitFeatures_requires_upfront_shutdown_script(&this_arg_conv);
40999 jboolean __attribute__((export_name("TS_NodeFeatures_requires_upfront_shutdown_script"))) TS_NodeFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
41000 LDKNodeFeatures this_arg_conv;
41001 this_arg_conv.inner = untag_ptr(this_arg);
41002 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41004 this_arg_conv.is_owned = false;
41005 jboolean ret_conv = NodeFeatures_requires_upfront_shutdown_script(&this_arg_conv);
41009 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_optional"))) TS_InitFeatures_set_gossip_queries_optional(uint64_t this_arg) {
41010 LDKInitFeatures this_arg_conv;
41011 this_arg_conv.inner = untag_ptr(this_arg);
41012 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41014 this_arg_conv.is_owned = false;
41015 InitFeatures_set_gossip_queries_optional(&this_arg_conv);
41018 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_required"))) TS_InitFeatures_set_gossip_queries_required(uint64_t this_arg) {
41019 LDKInitFeatures this_arg_conv;
41020 this_arg_conv.inner = untag_ptr(this_arg);
41021 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41023 this_arg_conv.is_owned = false;
41024 InitFeatures_set_gossip_queries_required(&this_arg_conv);
41027 jboolean __attribute__((export_name("TS_InitFeatures_supports_gossip_queries"))) TS_InitFeatures_supports_gossip_queries(uint64_t this_arg) {
41028 LDKInitFeatures this_arg_conv;
41029 this_arg_conv.inner = untag_ptr(this_arg);
41030 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41032 this_arg_conv.is_owned = false;
41033 jboolean ret_conv = InitFeatures_supports_gossip_queries(&this_arg_conv);
41037 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_optional"))) TS_NodeFeatures_set_gossip_queries_optional(uint64_t this_arg) {
41038 LDKNodeFeatures this_arg_conv;
41039 this_arg_conv.inner = untag_ptr(this_arg);
41040 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41042 this_arg_conv.is_owned = false;
41043 NodeFeatures_set_gossip_queries_optional(&this_arg_conv);
41046 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_required"))) TS_NodeFeatures_set_gossip_queries_required(uint64_t this_arg) {
41047 LDKNodeFeatures this_arg_conv;
41048 this_arg_conv.inner = untag_ptr(this_arg);
41049 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41050 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41051 this_arg_conv.is_owned = false;
41052 NodeFeatures_set_gossip_queries_required(&this_arg_conv);
41055 jboolean __attribute__((export_name("TS_NodeFeatures_supports_gossip_queries"))) TS_NodeFeatures_supports_gossip_queries(uint64_t this_arg) {
41056 LDKNodeFeatures this_arg_conv;
41057 this_arg_conv.inner = untag_ptr(this_arg);
41058 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41060 this_arg_conv.is_owned = false;
41061 jboolean ret_conv = NodeFeatures_supports_gossip_queries(&this_arg_conv);
41065 jboolean __attribute__((export_name("TS_InitFeatures_requires_gossip_queries"))) TS_InitFeatures_requires_gossip_queries(uint64_t this_arg) {
41066 LDKInitFeatures this_arg_conv;
41067 this_arg_conv.inner = untag_ptr(this_arg);
41068 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41069 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41070 this_arg_conv.is_owned = false;
41071 jboolean ret_conv = InitFeatures_requires_gossip_queries(&this_arg_conv);
41075 jboolean __attribute__((export_name("TS_NodeFeatures_requires_gossip_queries"))) TS_NodeFeatures_requires_gossip_queries(uint64_t this_arg) {
41076 LDKNodeFeatures this_arg_conv;
41077 this_arg_conv.inner = untag_ptr(this_arg);
41078 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41080 this_arg_conv.is_owned = false;
41081 jboolean ret_conv = NodeFeatures_requires_gossip_queries(&this_arg_conv);
41085 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_optional"))) TS_InitFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
41086 LDKInitFeatures this_arg_conv;
41087 this_arg_conv.inner = untag_ptr(this_arg);
41088 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41090 this_arg_conv.is_owned = false;
41091 InitFeatures_set_variable_length_onion_optional(&this_arg_conv);
41094 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_required"))) TS_InitFeatures_set_variable_length_onion_required(uint64_t this_arg) {
41095 LDKInitFeatures this_arg_conv;
41096 this_arg_conv.inner = untag_ptr(this_arg);
41097 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41098 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41099 this_arg_conv.is_owned = false;
41100 InitFeatures_set_variable_length_onion_required(&this_arg_conv);
41103 jboolean __attribute__((export_name("TS_InitFeatures_supports_variable_length_onion"))) TS_InitFeatures_supports_variable_length_onion(uint64_t this_arg) {
41104 LDKInitFeatures this_arg_conv;
41105 this_arg_conv.inner = untag_ptr(this_arg);
41106 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41108 this_arg_conv.is_owned = false;
41109 jboolean ret_conv = InitFeatures_supports_variable_length_onion(&this_arg_conv);
41113 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_optional"))) TS_NodeFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
41114 LDKNodeFeatures this_arg_conv;
41115 this_arg_conv.inner = untag_ptr(this_arg);
41116 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41118 this_arg_conv.is_owned = false;
41119 NodeFeatures_set_variable_length_onion_optional(&this_arg_conv);
41122 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_required"))) TS_NodeFeatures_set_variable_length_onion_required(uint64_t this_arg) {
41123 LDKNodeFeatures this_arg_conv;
41124 this_arg_conv.inner = untag_ptr(this_arg);
41125 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41127 this_arg_conv.is_owned = false;
41128 NodeFeatures_set_variable_length_onion_required(&this_arg_conv);
41131 jboolean __attribute__((export_name("TS_NodeFeatures_supports_variable_length_onion"))) TS_NodeFeatures_supports_variable_length_onion(uint64_t this_arg) {
41132 LDKNodeFeatures this_arg_conv;
41133 this_arg_conv.inner = untag_ptr(this_arg);
41134 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41135 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41136 this_arg_conv.is_owned = false;
41137 jboolean ret_conv = NodeFeatures_supports_variable_length_onion(&this_arg_conv);
41141 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_optional"))) TS_InvoiceFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
41142 LDKInvoiceFeatures this_arg_conv;
41143 this_arg_conv.inner = untag_ptr(this_arg);
41144 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41146 this_arg_conv.is_owned = false;
41147 InvoiceFeatures_set_variable_length_onion_optional(&this_arg_conv);
41150 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_required"))) TS_InvoiceFeatures_set_variable_length_onion_required(uint64_t this_arg) {
41151 LDKInvoiceFeatures this_arg_conv;
41152 this_arg_conv.inner = untag_ptr(this_arg);
41153 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41155 this_arg_conv.is_owned = false;
41156 InvoiceFeatures_set_variable_length_onion_required(&this_arg_conv);
41159 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_variable_length_onion"))) TS_InvoiceFeatures_supports_variable_length_onion(uint64_t this_arg) {
41160 LDKInvoiceFeatures this_arg_conv;
41161 this_arg_conv.inner = untag_ptr(this_arg);
41162 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41164 this_arg_conv.is_owned = false;
41165 jboolean ret_conv = InvoiceFeatures_supports_variable_length_onion(&this_arg_conv);
41169 jboolean __attribute__((export_name("TS_InitFeatures_requires_variable_length_onion"))) TS_InitFeatures_requires_variable_length_onion(uint64_t this_arg) {
41170 LDKInitFeatures this_arg_conv;
41171 this_arg_conv.inner = untag_ptr(this_arg);
41172 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41173 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41174 this_arg_conv.is_owned = false;
41175 jboolean ret_conv = InitFeatures_requires_variable_length_onion(&this_arg_conv);
41179 jboolean __attribute__((export_name("TS_NodeFeatures_requires_variable_length_onion"))) TS_NodeFeatures_requires_variable_length_onion(uint64_t this_arg) {
41180 LDKNodeFeatures this_arg_conv;
41181 this_arg_conv.inner = untag_ptr(this_arg);
41182 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41183 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41184 this_arg_conv.is_owned = false;
41185 jboolean ret_conv = NodeFeatures_requires_variable_length_onion(&this_arg_conv);
41189 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_variable_length_onion"))) TS_InvoiceFeatures_requires_variable_length_onion(uint64_t this_arg) {
41190 LDKInvoiceFeatures this_arg_conv;
41191 this_arg_conv.inner = untag_ptr(this_arg);
41192 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41193 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41194 this_arg_conv.is_owned = false;
41195 jboolean ret_conv = InvoiceFeatures_requires_variable_length_onion(&this_arg_conv);
41199 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_optional"))) TS_InitFeatures_set_static_remote_key_optional(uint64_t this_arg) {
41200 LDKInitFeatures this_arg_conv;
41201 this_arg_conv.inner = untag_ptr(this_arg);
41202 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41204 this_arg_conv.is_owned = false;
41205 InitFeatures_set_static_remote_key_optional(&this_arg_conv);
41208 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_required"))) TS_InitFeatures_set_static_remote_key_required(uint64_t this_arg) {
41209 LDKInitFeatures this_arg_conv;
41210 this_arg_conv.inner = untag_ptr(this_arg);
41211 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41212 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41213 this_arg_conv.is_owned = false;
41214 InitFeatures_set_static_remote_key_required(&this_arg_conv);
41217 jboolean __attribute__((export_name("TS_InitFeatures_supports_static_remote_key"))) TS_InitFeatures_supports_static_remote_key(uint64_t this_arg) {
41218 LDKInitFeatures this_arg_conv;
41219 this_arg_conv.inner = untag_ptr(this_arg);
41220 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41222 this_arg_conv.is_owned = false;
41223 jboolean ret_conv = InitFeatures_supports_static_remote_key(&this_arg_conv);
41227 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_optional"))) TS_NodeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
41228 LDKNodeFeatures this_arg_conv;
41229 this_arg_conv.inner = untag_ptr(this_arg);
41230 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41231 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41232 this_arg_conv.is_owned = false;
41233 NodeFeatures_set_static_remote_key_optional(&this_arg_conv);
41236 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_required"))) TS_NodeFeatures_set_static_remote_key_required(uint64_t this_arg) {
41237 LDKNodeFeatures this_arg_conv;
41238 this_arg_conv.inner = untag_ptr(this_arg);
41239 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41241 this_arg_conv.is_owned = false;
41242 NodeFeatures_set_static_remote_key_required(&this_arg_conv);
41245 jboolean __attribute__((export_name("TS_NodeFeatures_supports_static_remote_key"))) TS_NodeFeatures_supports_static_remote_key(uint64_t this_arg) {
41246 LDKNodeFeatures this_arg_conv;
41247 this_arg_conv.inner = untag_ptr(this_arg);
41248 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41250 this_arg_conv.is_owned = false;
41251 jboolean ret_conv = NodeFeatures_supports_static_remote_key(&this_arg_conv);
41255 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_optional"))) TS_ChannelTypeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
41256 LDKChannelTypeFeatures this_arg_conv;
41257 this_arg_conv.inner = untag_ptr(this_arg);
41258 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41260 this_arg_conv.is_owned = false;
41261 ChannelTypeFeatures_set_static_remote_key_optional(&this_arg_conv);
41264 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_required"))) TS_ChannelTypeFeatures_set_static_remote_key_required(uint64_t this_arg) {
41265 LDKChannelTypeFeatures this_arg_conv;
41266 this_arg_conv.inner = untag_ptr(this_arg);
41267 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41269 this_arg_conv.is_owned = false;
41270 ChannelTypeFeatures_set_static_remote_key_required(&this_arg_conv);
41273 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_static_remote_key"))) TS_ChannelTypeFeatures_supports_static_remote_key(uint64_t this_arg) {
41274 LDKChannelTypeFeatures this_arg_conv;
41275 this_arg_conv.inner = untag_ptr(this_arg);
41276 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41278 this_arg_conv.is_owned = false;
41279 jboolean ret_conv = ChannelTypeFeatures_supports_static_remote_key(&this_arg_conv);
41283 jboolean __attribute__((export_name("TS_InitFeatures_requires_static_remote_key"))) TS_InitFeatures_requires_static_remote_key(uint64_t this_arg) {
41284 LDKInitFeatures this_arg_conv;
41285 this_arg_conv.inner = untag_ptr(this_arg);
41286 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41288 this_arg_conv.is_owned = false;
41289 jboolean ret_conv = InitFeatures_requires_static_remote_key(&this_arg_conv);
41293 jboolean __attribute__((export_name("TS_NodeFeatures_requires_static_remote_key"))) TS_NodeFeatures_requires_static_remote_key(uint64_t this_arg) {
41294 LDKNodeFeatures this_arg_conv;
41295 this_arg_conv.inner = untag_ptr(this_arg);
41296 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41297 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41298 this_arg_conv.is_owned = false;
41299 jboolean ret_conv = NodeFeatures_requires_static_remote_key(&this_arg_conv);
41303 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_static_remote_key"))) TS_ChannelTypeFeatures_requires_static_remote_key(uint64_t this_arg) {
41304 LDKChannelTypeFeatures this_arg_conv;
41305 this_arg_conv.inner = untag_ptr(this_arg);
41306 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41308 this_arg_conv.is_owned = false;
41309 jboolean ret_conv = ChannelTypeFeatures_requires_static_remote_key(&this_arg_conv);
41313 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_optional"))) TS_InitFeatures_set_payment_secret_optional(uint64_t this_arg) {
41314 LDKInitFeatures this_arg_conv;
41315 this_arg_conv.inner = untag_ptr(this_arg);
41316 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41318 this_arg_conv.is_owned = false;
41319 InitFeatures_set_payment_secret_optional(&this_arg_conv);
41322 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_required"))) TS_InitFeatures_set_payment_secret_required(uint64_t this_arg) {
41323 LDKInitFeatures this_arg_conv;
41324 this_arg_conv.inner = untag_ptr(this_arg);
41325 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41326 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41327 this_arg_conv.is_owned = false;
41328 InitFeatures_set_payment_secret_required(&this_arg_conv);
41331 jboolean __attribute__((export_name("TS_InitFeatures_supports_payment_secret"))) TS_InitFeatures_supports_payment_secret(uint64_t this_arg) {
41332 LDKInitFeatures this_arg_conv;
41333 this_arg_conv.inner = untag_ptr(this_arg);
41334 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41336 this_arg_conv.is_owned = false;
41337 jboolean ret_conv = InitFeatures_supports_payment_secret(&this_arg_conv);
41341 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_optional"))) TS_NodeFeatures_set_payment_secret_optional(uint64_t this_arg) {
41342 LDKNodeFeatures this_arg_conv;
41343 this_arg_conv.inner = untag_ptr(this_arg);
41344 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41346 this_arg_conv.is_owned = false;
41347 NodeFeatures_set_payment_secret_optional(&this_arg_conv);
41350 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_required"))) TS_NodeFeatures_set_payment_secret_required(uint64_t this_arg) {
41351 LDKNodeFeatures this_arg_conv;
41352 this_arg_conv.inner = untag_ptr(this_arg);
41353 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41354 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41355 this_arg_conv.is_owned = false;
41356 NodeFeatures_set_payment_secret_required(&this_arg_conv);
41359 jboolean __attribute__((export_name("TS_NodeFeatures_supports_payment_secret"))) TS_NodeFeatures_supports_payment_secret(uint64_t this_arg) {
41360 LDKNodeFeatures this_arg_conv;
41361 this_arg_conv.inner = untag_ptr(this_arg);
41362 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41364 this_arg_conv.is_owned = false;
41365 jboolean ret_conv = NodeFeatures_supports_payment_secret(&this_arg_conv);
41369 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_optional"))) TS_InvoiceFeatures_set_payment_secret_optional(uint64_t this_arg) {
41370 LDKInvoiceFeatures this_arg_conv;
41371 this_arg_conv.inner = untag_ptr(this_arg);
41372 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41374 this_arg_conv.is_owned = false;
41375 InvoiceFeatures_set_payment_secret_optional(&this_arg_conv);
41378 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_required"))) TS_InvoiceFeatures_set_payment_secret_required(uint64_t this_arg) {
41379 LDKInvoiceFeatures this_arg_conv;
41380 this_arg_conv.inner = untag_ptr(this_arg);
41381 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41383 this_arg_conv.is_owned = false;
41384 InvoiceFeatures_set_payment_secret_required(&this_arg_conv);
41387 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_payment_secret"))) TS_InvoiceFeatures_supports_payment_secret(uint64_t this_arg) {
41388 LDKInvoiceFeatures this_arg_conv;
41389 this_arg_conv.inner = untag_ptr(this_arg);
41390 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41391 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41392 this_arg_conv.is_owned = false;
41393 jboolean ret_conv = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
41397 jboolean __attribute__((export_name("TS_InitFeatures_requires_payment_secret"))) TS_InitFeatures_requires_payment_secret(uint64_t this_arg) {
41398 LDKInitFeatures this_arg_conv;
41399 this_arg_conv.inner = untag_ptr(this_arg);
41400 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41401 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41402 this_arg_conv.is_owned = false;
41403 jboolean ret_conv = InitFeatures_requires_payment_secret(&this_arg_conv);
41407 jboolean __attribute__((export_name("TS_NodeFeatures_requires_payment_secret"))) TS_NodeFeatures_requires_payment_secret(uint64_t this_arg) {
41408 LDKNodeFeatures this_arg_conv;
41409 this_arg_conv.inner = untag_ptr(this_arg);
41410 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41412 this_arg_conv.is_owned = false;
41413 jboolean ret_conv = NodeFeatures_requires_payment_secret(&this_arg_conv);
41417 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_payment_secret"))) TS_InvoiceFeatures_requires_payment_secret(uint64_t this_arg) {
41418 LDKInvoiceFeatures this_arg_conv;
41419 this_arg_conv.inner = untag_ptr(this_arg);
41420 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41421 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41422 this_arg_conv.is_owned = false;
41423 jboolean ret_conv = InvoiceFeatures_requires_payment_secret(&this_arg_conv);
41427 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_optional"))) TS_InitFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41428 LDKInitFeatures this_arg_conv;
41429 this_arg_conv.inner = untag_ptr(this_arg);
41430 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41431 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41432 this_arg_conv.is_owned = false;
41433 InitFeatures_set_basic_mpp_optional(&this_arg_conv);
41436 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_required"))) TS_InitFeatures_set_basic_mpp_required(uint64_t this_arg) {
41437 LDKInitFeatures this_arg_conv;
41438 this_arg_conv.inner = untag_ptr(this_arg);
41439 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41440 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41441 this_arg_conv.is_owned = false;
41442 InitFeatures_set_basic_mpp_required(&this_arg_conv);
41445 jboolean __attribute__((export_name("TS_InitFeatures_supports_basic_mpp"))) TS_InitFeatures_supports_basic_mpp(uint64_t this_arg) {
41446 LDKInitFeatures this_arg_conv;
41447 this_arg_conv.inner = untag_ptr(this_arg);
41448 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41450 this_arg_conv.is_owned = false;
41451 jboolean ret_conv = InitFeatures_supports_basic_mpp(&this_arg_conv);
41455 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_optional"))) TS_NodeFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41456 LDKNodeFeatures this_arg_conv;
41457 this_arg_conv.inner = untag_ptr(this_arg);
41458 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41460 this_arg_conv.is_owned = false;
41461 NodeFeatures_set_basic_mpp_optional(&this_arg_conv);
41464 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_required"))) TS_NodeFeatures_set_basic_mpp_required(uint64_t this_arg) {
41465 LDKNodeFeatures this_arg_conv;
41466 this_arg_conv.inner = untag_ptr(this_arg);
41467 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41469 this_arg_conv.is_owned = false;
41470 NodeFeatures_set_basic_mpp_required(&this_arg_conv);
41473 jboolean __attribute__((export_name("TS_NodeFeatures_supports_basic_mpp"))) TS_NodeFeatures_supports_basic_mpp(uint64_t this_arg) {
41474 LDKNodeFeatures this_arg_conv;
41475 this_arg_conv.inner = untag_ptr(this_arg);
41476 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41478 this_arg_conv.is_owned = false;
41479 jboolean ret_conv = NodeFeatures_supports_basic_mpp(&this_arg_conv);
41483 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_optional"))) TS_InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41484 LDKInvoiceFeatures this_arg_conv;
41485 this_arg_conv.inner = untag_ptr(this_arg);
41486 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41488 this_arg_conv.is_owned = false;
41489 InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
41492 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_required"))) TS_InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
41493 LDKInvoiceFeatures this_arg_conv;
41494 this_arg_conv.inner = untag_ptr(this_arg);
41495 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41497 this_arg_conv.is_owned = false;
41498 InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
41501 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_basic_mpp"))) TS_InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
41502 LDKInvoiceFeatures this_arg_conv;
41503 this_arg_conv.inner = untag_ptr(this_arg);
41504 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41506 this_arg_conv.is_owned = false;
41507 jboolean ret_conv = InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
41511 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_basic_mpp_optional"))) TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
41512 LDKBolt12InvoiceFeatures this_arg_conv;
41513 this_arg_conv.inner = untag_ptr(this_arg);
41514 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41516 this_arg_conv.is_owned = false;
41517 Bolt12InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
41520 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_basic_mpp_required"))) TS_Bolt12InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
41521 LDKBolt12InvoiceFeatures this_arg_conv;
41522 this_arg_conv.inner = untag_ptr(this_arg);
41523 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41524 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41525 this_arg_conv.is_owned = false;
41526 Bolt12InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
41529 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_supports_basic_mpp"))) TS_Bolt12InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
41530 LDKBolt12InvoiceFeatures this_arg_conv;
41531 this_arg_conv.inner = untag_ptr(this_arg);
41532 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41533 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41534 this_arg_conv.is_owned = false;
41535 jboolean ret_conv = Bolt12InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
41539 jboolean __attribute__((export_name("TS_InitFeatures_requires_basic_mpp"))) TS_InitFeatures_requires_basic_mpp(uint64_t this_arg) {
41540 LDKInitFeatures this_arg_conv;
41541 this_arg_conv.inner = untag_ptr(this_arg);
41542 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41543 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41544 this_arg_conv.is_owned = false;
41545 jboolean ret_conv = InitFeatures_requires_basic_mpp(&this_arg_conv);
41549 jboolean __attribute__((export_name("TS_NodeFeatures_requires_basic_mpp"))) TS_NodeFeatures_requires_basic_mpp(uint64_t this_arg) {
41550 LDKNodeFeatures this_arg_conv;
41551 this_arg_conv.inner = untag_ptr(this_arg);
41552 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41554 this_arg_conv.is_owned = false;
41555 jboolean ret_conv = NodeFeatures_requires_basic_mpp(&this_arg_conv);
41559 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_basic_mpp"))) TS_InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
41560 LDKInvoiceFeatures this_arg_conv;
41561 this_arg_conv.inner = untag_ptr(this_arg);
41562 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41563 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41564 this_arg_conv.is_owned = false;
41565 jboolean ret_conv = InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
41569 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_basic_mpp"))) TS_Bolt12InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
41570 LDKBolt12InvoiceFeatures this_arg_conv;
41571 this_arg_conv.inner = untag_ptr(this_arg);
41572 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41574 this_arg_conv.is_owned = false;
41575 jboolean ret_conv = Bolt12InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
41579 void __attribute__((export_name("TS_InitFeatures_set_wumbo_optional"))) TS_InitFeatures_set_wumbo_optional(uint64_t this_arg) {
41580 LDKInitFeatures this_arg_conv;
41581 this_arg_conv.inner = untag_ptr(this_arg);
41582 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41584 this_arg_conv.is_owned = false;
41585 InitFeatures_set_wumbo_optional(&this_arg_conv);
41588 void __attribute__((export_name("TS_InitFeatures_set_wumbo_required"))) TS_InitFeatures_set_wumbo_required(uint64_t this_arg) {
41589 LDKInitFeatures this_arg_conv;
41590 this_arg_conv.inner = untag_ptr(this_arg);
41591 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41593 this_arg_conv.is_owned = false;
41594 InitFeatures_set_wumbo_required(&this_arg_conv);
41597 jboolean __attribute__((export_name("TS_InitFeatures_supports_wumbo"))) TS_InitFeatures_supports_wumbo(uint64_t this_arg) {
41598 LDKInitFeatures this_arg_conv;
41599 this_arg_conv.inner = untag_ptr(this_arg);
41600 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41602 this_arg_conv.is_owned = false;
41603 jboolean ret_conv = InitFeatures_supports_wumbo(&this_arg_conv);
41607 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_optional"))) TS_NodeFeatures_set_wumbo_optional(uint64_t this_arg) {
41608 LDKNodeFeatures this_arg_conv;
41609 this_arg_conv.inner = untag_ptr(this_arg);
41610 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41611 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41612 this_arg_conv.is_owned = false;
41613 NodeFeatures_set_wumbo_optional(&this_arg_conv);
41616 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_required"))) TS_NodeFeatures_set_wumbo_required(uint64_t this_arg) {
41617 LDKNodeFeatures this_arg_conv;
41618 this_arg_conv.inner = untag_ptr(this_arg);
41619 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41620 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41621 this_arg_conv.is_owned = false;
41622 NodeFeatures_set_wumbo_required(&this_arg_conv);
41625 jboolean __attribute__((export_name("TS_NodeFeatures_supports_wumbo"))) TS_NodeFeatures_supports_wumbo(uint64_t this_arg) {
41626 LDKNodeFeatures this_arg_conv;
41627 this_arg_conv.inner = untag_ptr(this_arg);
41628 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41630 this_arg_conv.is_owned = false;
41631 jboolean ret_conv = NodeFeatures_supports_wumbo(&this_arg_conv);
41635 jboolean __attribute__((export_name("TS_InitFeatures_requires_wumbo"))) TS_InitFeatures_requires_wumbo(uint64_t this_arg) {
41636 LDKInitFeatures this_arg_conv;
41637 this_arg_conv.inner = untag_ptr(this_arg);
41638 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41640 this_arg_conv.is_owned = false;
41641 jboolean ret_conv = InitFeatures_requires_wumbo(&this_arg_conv);
41645 jboolean __attribute__((export_name("TS_NodeFeatures_requires_wumbo"))) TS_NodeFeatures_requires_wumbo(uint64_t this_arg) {
41646 LDKNodeFeatures this_arg_conv;
41647 this_arg_conv.inner = untag_ptr(this_arg);
41648 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41650 this_arg_conv.is_owned = false;
41651 jboolean ret_conv = NodeFeatures_requires_wumbo(&this_arg_conv);
41655 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) {
41656 LDKInitFeatures this_arg_conv;
41657 this_arg_conv.inner = untag_ptr(this_arg);
41658 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41659 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41660 this_arg_conv.is_owned = false;
41661 InitFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
41664 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) {
41665 LDKInitFeatures this_arg_conv;
41666 this_arg_conv.inner = untag_ptr(this_arg);
41667 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41668 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41669 this_arg_conv.is_owned = false;
41670 InitFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
41673 jboolean __attribute__((export_name("TS_InitFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41674 LDKInitFeatures this_arg_conv;
41675 this_arg_conv.inner = untag_ptr(this_arg);
41676 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41677 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41678 this_arg_conv.is_owned = false;
41679 jboolean ret_conv = InitFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
41683 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) {
41684 LDKNodeFeatures this_arg_conv;
41685 this_arg_conv.inner = untag_ptr(this_arg);
41686 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41687 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41688 this_arg_conv.is_owned = false;
41689 NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
41692 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) {
41693 LDKNodeFeatures this_arg_conv;
41694 this_arg_conv.inner = untag_ptr(this_arg);
41695 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41696 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41697 this_arg_conv.is_owned = false;
41698 NodeFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
41701 jboolean __attribute__((export_name("TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41702 LDKNodeFeatures this_arg_conv;
41703 this_arg_conv.inner = untag_ptr(this_arg);
41704 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41706 this_arg_conv.is_owned = false;
41707 jboolean ret_conv = NodeFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
41711 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) {
41712 LDKChannelTypeFeatures this_arg_conv;
41713 this_arg_conv.inner = untag_ptr(this_arg);
41714 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41715 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41716 this_arg_conv.is_owned = false;
41717 ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
41720 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) {
41721 LDKChannelTypeFeatures this_arg_conv;
41722 this_arg_conv.inner = untag_ptr(this_arg);
41723 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41724 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41725 this_arg_conv.is_owned = false;
41726 ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
41729 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41730 LDKChannelTypeFeatures this_arg_conv;
41731 this_arg_conv.inner = untag_ptr(this_arg);
41732 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41734 this_arg_conv.is_owned = false;
41735 jboolean ret_conv = ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
41739 jboolean __attribute__((export_name("TS_InitFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41740 LDKInitFeatures this_arg_conv;
41741 this_arg_conv.inner = untag_ptr(this_arg);
41742 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41744 this_arg_conv.is_owned = false;
41745 jboolean ret_conv = InitFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
41749 jboolean __attribute__((export_name("TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41750 LDKNodeFeatures this_arg_conv;
41751 this_arg_conv.inner = untag_ptr(this_arg);
41752 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41754 this_arg_conv.is_owned = false;
41755 jboolean ret_conv = NodeFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
41759 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
41760 LDKChannelTypeFeatures this_arg_conv;
41761 this_arg_conv.inner = untag_ptr(this_arg);
41762 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41764 this_arg_conv.is_owned = false;
41765 jboolean ret_conv = ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
41769 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_optional"))) TS_InitFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
41770 LDKInitFeatures this_arg_conv;
41771 this_arg_conv.inner = untag_ptr(this_arg);
41772 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41774 this_arg_conv.is_owned = false;
41775 InitFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
41778 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_required"))) TS_InitFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
41779 LDKInitFeatures this_arg_conv;
41780 this_arg_conv.inner = untag_ptr(this_arg);
41781 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41782 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41783 this_arg_conv.is_owned = false;
41784 InitFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
41787 jboolean __attribute__((export_name("TS_InitFeatures_supports_shutdown_anysegwit"))) TS_InitFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
41788 LDKInitFeatures this_arg_conv;
41789 this_arg_conv.inner = untag_ptr(this_arg);
41790 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41792 this_arg_conv.is_owned = false;
41793 jboolean ret_conv = InitFeatures_supports_shutdown_anysegwit(&this_arg_conv);
41797 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_optional"))) TS_NodeFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
41798 LDKNodeFeatures this_arg_conv;
41799 this_arg_conv.inner = untag_ptr(this_arg);
41800 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41802 this_arg_conv.is_owned = false;
41803 NodeFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
41806 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_required"))) TS_NodeFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
41807 LDKNodeFeatures this_arg_conv;
41808 this_arg_conv.inner = untag_ptr(this_arg);
41809 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41811 this_arg_conv.is_owned = false;
41812 NodeFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
41815 jboolean __attribute__((export_name("TS_NodeFeatures_supports_shutdown_anysegwit"))) TS_NodeFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
41816 LDKNodeFeatures this_arg_conv;
41817 this_arg_conv.inner = untag_ptr(this_arg);
41818 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41820 this_arg_conv.is_owned = false;
41821 jboolean ret_conv = NodeFeatures_supports_shutdown_anysegwit(&this_arg_conv);
41825 jboolean __attribute__((export_name("TS_InitFeatures_requires_shutdown_anysegwit"))) TS_InitFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
41826 LDKInitFeatures this_arg_conv;
41827 this_arg_conv.inner = untag_ptr(this_arg);
41828 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41829 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41830 this_arg_conv.is_owned = false;
41831 jboolean ret_conv = InitFeatures_requires_shutdown_anysegwit(&this_arg_conv);
41835 jboolean __attribute__((export_name("TS_NodeFeatures_requires_shutdown_anysegwit"))) TS_NodeFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
41836 LDKNodeFeatures this_arg_conv;
41837 this_arg_conv.inner = untag_ptr(this_arg);
41838 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41840 this_arg_conv.is_owned = false;
41841 jboolean ret_conv = NodeFeatures_requires_shutdown_anysegwit(&this_arg_conv);
41845 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_optional"))) TS_InitFeatures_set_onion_messages_optional(uint64_t this_arg) {
41846 LDKInitFeatures this_arg_conv;
41847 this_arg_conv.inner = untag_ptr(this_arg);
41848 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41849 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41850 this_arg_conv.is_owned = false;
41851 InitFeatures_set_onion_messages_optional(&this_arg_conv);
41854 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_required"))) TS_InitFeatures_set_onion_messages_required(uint64_t this_arg) {
41855 LDKInitFeatures this_arg_conv;
41856 this_arg_conv.inner = untag_ptr(this_arg);
41857 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41858 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41859 this_arg_conv.is_owned = false;
41860 InitFeatures_set_onion_messages_required(&this_arg_conv);
41863 jboolean __attribute__((export_name("TS_InitFeatures_supports_onion_messages"))) TS_InitFeatures_supports_onion_messages(uint64_t this_arg) {
41864 LDKInitFeatures this_arg_conv;
41865 this_arg_conv.inner = untag_ptr(this_arg);
41866 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41868 this_arg_conv.is_owned = false;
41869 jboolean ret_conv = InitFeatures_supports_onion_messages(&this_arg_conv);
41873 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_optional"))) TS_NodeFeatures_set_onion_messages_optional(uint64_t this_arg) {
41874 LDKNodeFeatures this_arg_conv;
41875 this_arg_conv.inner = untag_ptr(this_arg);
41876 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41878 this_arg_conv.is_owned = false;
41879 NodeFeatures_set_onion_messages_optional(&this_arg_conv);
41882 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_required"))) TS_NodeFeatures_set_onion_messages_required(uint64_t this_arg) {
41883 LDKNodeFeatures this_arg_conv;
41884 this_arg_conv.inner = untag_ptr(this_arg);
41885 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41887 this_arg_conv.is_owned = false;
41888 NodeFeatures_set_onion_messages_required(&this_arg_conv);
41891 jboolean __attribute__((export_name("TS_NodeFeatures_supports_onion_messages"))) TS_NodeFeatures_supports_onion_messages(uint64_t this_arg) {
41892 LDKNodeFeatures this_arg_conv;
41893 this_arg_conv.inner = untag_ptr(this_arg);
41894 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41896 this_arg_conv.is_owned = false;
41897 jboolean ret_conv = NodeFeatures_supports_onion_messages(&this_arg_conv);
41901 jboolean __attribute__((export_name("TS_InitFeatures_requires_onion_messages"))) TS_InitFeatures_requires_onion_messages(uint64_t this_arg) {
41902 LDKInitFeatures this_arg_conv;
41903 this_arg_conv.inner = untag_ptr(this_arg);
41904 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41906 this_arg_conv.is_owned = false;
41907 jboolean ret_conv = InitFeatures_requires_onion_messages(&this_arg_conv);
41911 jboolean __attribute__((export_name("TS_NodeFeatures_requires_onion_messages"))) TS_NodeFeatures_requires_onion_messages(uint64_t this_arg) {
41912 LDKNodeFeatures this_arg_conv;
41913 this_arg_conv.inner = untag_ptr(this_arg);
41914 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41916 this_arg_conv.is_owned = false;
41917 jboolean ret_conv = NodeFeatures_requires_onion_messages(&this_arg_conv);
41921 void __attribute__((export_name("TS_InitFeatures_set_channel_type_optional"))) TS_InitFeatures_set_channel_type_optional(uint64_t this_arg) {
41922 LDKInitFeatures this_arg_conv;
41923 this_arg_conv.inner = untag_ptr(this_arg);
41924 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41926 this_arg_conv.is_owned = false;
41927 InitFeatures_set_channel_type_optional(&this_arg_conv);
41930 void __attribute__((export_name("TS_InitFeatures_set_channel_type_required"))) TS_InitFeatures_set_channel_type_required(uint64_t this_arg) {
41931 LDKInitFeatures this_arg_conv;
41932 this_arg_conv.inner = untag_ptr(this_arg);
41933 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41935 this_arg_conv.is_owned = false;
41936 InitFeatures_set_channel_type_required(&this_arg_conv);
41939 jboolean __attribute__((export_name("TS_InitFeatures_supports_channel_type"))) TS_InitFeatures_supports_channel_type(uint64_t this_arg) {
41940 LDKInitFeatures this_arg_conv;
41941 this_arg_conv.inner = untag_ptr(this_arg);
41942 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41943 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41944 this_arg_conv.is_owned = false;
41945 jboolean ret_conv = InitFeatures_supports_channel_type(&this_arg_conv);
41949 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_optional"))) TS_NodeFeatures_set_channel_type_optional(uint64_t this_arg) {
41950 LDKNodeFeatures this_arg_conv;
41951 this_arg_conv.inner = untag_ptr(this_arg);
41952 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41954 this_arg_conv.is_owned = false;
41955 NodeFeatures_set_channel_type_optional(&this_arg_conv);
41958 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_required"))) TS_NodeFeatures_set_channel_type_required(uint64_t this_arg) {
41959 LDKNodeFeatures this_arg_conv;
41960 this_arg_conv.inner = untag_ptr(this_arg);
41961 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41963 this_arg_conv.is_owned = false;
41964 NodeFeatures_set_channel_type_required(&this_arg_conv);
41967 jboolean __attribute__((export_name("TS_NodeFeatures_supports_channel_type"))) TS_NodeFeatures_supports_channel_type(uint64_t this_arg) {
41968 LDKNodeFeatures this_arg_conv;
41969 this_arg_conv.inner = untag_ptr(this_arg);
41970 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41972 this_arg_conv.is_owned = false;
41973 jboolean ret_conv = NodeFeatures_supports_channel_type(&this_arg_conv);
41977 jboolean __attribute__((export_name("TS_InitFeatures_requires_channel_type"))) TS_InitFeatures_requires_channel_type(uint64_t this_arg) {
41978 LDKInitFeatures this_arg_conv;
41979 this_arg_conv.inner = untag_ptr(this_arg);
41980 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41982 this_arg_conv.is_owned = false;
41983 jboolean ret_conv = InitFeatures_requires_channel_type(&this_arg_conv);
41987 jboolean __attribute__((export_name("TS_NodeFeatures_requires_channel_type"))) TS_NodeFeatures_requires_channel_type(uint64_t this_arg) {
41988 LDKNodeFeatures this_arg_conv;
41989 this_arg_conv.inner = untag_ptr(this_arg);
41990 this_arg_conv.is_owned = ptr_is_owned(this_arg);
41991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41992 this_arg_conv.is_owned = false;
41993 jboolean ret_conv = NodeFeatures_requires_channel_type(&this_arg_conv);
41997 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_optional"))) TS_InitFeatures_set_scid_privacy_optional(uint64_t this_arg) {
41998 LDKInitFeatures this_arg_conv;
41999 this_arg_conv.inner = untag_ptr(this_arg);
42000 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42002 this_arg_conv.is_owned = false;
42003 InitFeatures_set_scid_privacy_optional(&this_arg_conv);
42006 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_required"))) TS_InitFeatures_set_scid_privacy_required(uint64_t this_arg) {
42007 LDKInitFeatures this_arg_conv;
42008 this_arg_conv.inner = untag_ptr(this_arg);
42009 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42011 this_arg_conv.is_owned = false;
42012 InitFeatures_set_scid_privacy_required(&this_arg_conv);
42015 jboolean __attribute__((export_name("TS_InitFeatures_supports_scid_privacy"))) TS_InitFeatures_supports_scid_privacy(uint64_t this_arg) {
42016 LDKInitFeatures this_arg_conv;
42017 this_arg_conv.inner = untag_ptr(this_arg);
42018 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42020 this_arg_conv.is_owned = false;
42021 jboolean ret_conv = InitFeatures_supports_scid_privacy(&this_arg_conv);
42025 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_optional"))) TS_NodeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
42026 LDKNodeFeatures this_arg_conv;
42027 this_arg_conv.inner = untag_ptr(this_arg);
42028 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42030 this_arg_conv.is_owned = false;
42031 NodeFeatures_set_scid_privacy_optional(&this_arg_conv);
42034 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_required"))) TS_NodeFeatures_set_scid_privacy_required(uint64_t this_arg) {
42035 LDKNodeFeatures this_arg_conv;
42036 this_arg_conv.inner = untag_ptr(this_arg);
42037 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42039 this_arg_conv.is_owned = false;
42040 NodeFeatures_set_scid_privacy_required(&this_arg_conv);
42043 jboolean __attribute__((export_name("TS_NodeFeatures_supports_scid_privacy"))) TS_NodeFeatures_supports_scid_privacy(uint64_t this_arg) {
42044 LDKNodeFeatures this_arg_conv;
42045 this_arg_conv.inner = untag_ptr(this_arg);
42046 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42047 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42048 this_arg_conv.is_owned = false;
42049 jboolean ret_conv = NodeFeatures_supports_scid_privacy(&this_arg_conv);
42053 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_optional"))) TS_ChannelTypeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
42054 LDKChannelTypeFeatures this_arg_conv;
42055 this_arg_conv.inner = untag_ptr(this_arg);
42056 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42058 this_arg_conv.is_owned = false;
42059 ChannelTypeFeatures_set_scid_privacy_optional(&this_arg_conv);
42062 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_required"))) TS_ChannelTypeFeatures_set_scid_privacy_required(uint64_t this_arg) {
42063 LDKChannelTypeFeatures this_arg_conv;
42064 this_arg_conv.inner = untag_ptr(this_arg);
42065 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42067 this_arg_conv.is_owned = false;
42068 ChannelTypeFeatures_set_scid_privacy_required(&this_arg_conv);
42071 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_scid_privacy"))) TS_ChannelTypeFeatures_supports_scid_privacy(uint64_t this_arg) {
42072 LDKChannelTypeFeatures this_arg_conv;
42073 this_arg_conv.inner = untag_ptr(this_arg);
42074 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42075 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42076 this_arg_conv.is_owned = false;
42077 jboolean ret_conv = ChannelTypeFeatures_supports_scid_privacy(&this_arg_conv);
42081 jboolean __attribute__((export_name("TS_InitFeatures_requires_scid_privacy"))) TS_InitFeatures_requires_scid_privacy(uint64_t this_arg) {
42082 LDKInitFeatures this_arg_conv;
42083 this_arg_conv.inner = untag_ptr(this_arg);
42084 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42085 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42086 this_arg_conv.is_owned = false;
42087 jboolean ret_conv = InitFeatures_requires_scid_privacy(&this_arg_conv);
42091 jboolean __attribute__((export_name("TS_NodeFeatures_requires_scid_privacy"))) TS_NodeFeatures_requires_scid_privacy(uint64_t this_arg) {
42092 LDKNodeFeatures this_arg_conv;
42093 this_arg_conv.inner = untag_ptr(this_arg);
42094 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42096 this_arg_conv.is_owned = false;
42097 jboolean ret_conv = NodeFeatures_requires_scid_privacy(&this_arg_conv);
42101 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_scid_privacy"))) TS_ChannelTypeFeatures_requires_scid_privacy(uint64_t this_arg) {
42102 LDKChannelTypeFeatures this_arg_conv;
42103 this_arg_conv.inner = untag_ptr(this_arg);
42104 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42106 this_arg_conv.is_owned = false;
42107 jboolean ret_conv = ChannelTypeFeatures_requires_scid_privacy(&this_arg_conv);
42111 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_metadata_optional"))) TS_InvoiceFeatures_set_payment_metadata_optional(uint64_t this_arg) {
42112 LDKInvoiceFeatures this_arg_conv;
42113 this_arg_conv.inner = untag_ptr(this_arg);
42114 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42116 this_arg_conv.is_owned = false;
42117 InvoiceFeatures_set_payment_metadata_optional(&this_arg_conv);
42120 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_metadata_required"))) TS_InvoiceFeatures_set_payment_metadata_required(uint64_t this_arg) {
42121 LDKInvoiceFeatures this_arg_conv;
42122 this_arg_conv.inner = untag_ptr(this_arg);
42123 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42124 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42125 this_arg_conv.is_owned = false;
42126 InvoiceFeatures_set_payment_metadata_required(&this_arg_conv);
42129 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_payment_metadata"))) TS_InvoiceFeatures_supports_payment_metadata(uint64_t this_arg) {
42130 LDKInvoiceFeatures this_arg_conv;
42131 this_arg_conv.inner = untag_ptr(this_arg);
42132 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42134 this_arg_conv.is_owned = false;
42135 jboolean ret_conv = InvoiceFeatures_supports_payment_metadata(&this_arg_conv);
42139 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_payment_metadata"))) TS_InvoiceFeatures_requires_payment_metadata(uint64_t this_arg) {
42140 LDKInvoiceFeatures this_arg_conv;
42141 this_arg_conv.inner = untag_ptr(this_arg);
42142 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42144 this_arg_conv.is_owned = false;
42145 jboolean ret_conv = InvoiceFeatures_requires_payment_metadata(&this_arg_conv);
42149 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_optional"))) TS_InitFeatures_set_zero_conf_optional(uint64_t this_arg) {
42150 LDKInitFeatures this_arg_conv;
42151 this_arg_conv.inner = untag_ptr(this_arg);
42152 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42154 this_arg_conv.is_owned = false;
42155 InitFeatures_set_zero_conf_optional(&this_arg_conv);
42158 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_required"))) TS_InitFeatures_set_zero_conf_required(uint64_t this_arg) {
42159 LDKInitFeatures this_arg_conv;
42160 this_arg_conv.inner = untag_ptr(this_arg);
42161 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42163 this_arg_conv.is_owned = false;
42164 InitFeatures_set_zero_conf_required(&this_arg_conv);
42167 jboolean __attribute__((export_name("TS_InitFeatures_supports_zero_conf"))) TS_InitFeatures_supports_zero_conf(uint64_t this_arg) {
42168 LDKInitFeatures this_arg_conv;
42169 this_arg_conv.inner = untag_ptr(this_arg);
42170 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42172 this_arg_conv.is_owned = false;
42173 jboolean ret_conv = InitFeatures_supports_zero_conf(&this_arg_conv);
42177 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_optional"))) TS_NodeFeatures_set_zero_conf_optional(uint64_t this_arg) {
42178 LDKNodeFeatures this_arg_conv;
42179 this_arg_conv.inner = untag_ptr(this_arg);
42180 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42181 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42182 this_arg_conv.is_owned = false;
42183 NodeFeatures_set_zero_conf_optional(&this_arg_conv);
42186 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_required"))) TS_NodeFeatures_set_zero_conf_required(uint64_t this_arg) {
42187 LDKNodeFeatures this_arg_conv;
42188 this_arg_conv.inner = untag_ptr(this_arg);
42189 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42191 this_arg_conv.is_owned = false;
42192 NodeFeatures_set_zero_conf_required(&this_arg_conv);
42195 jboolean __attribute__((export_name("TS_NodeFeatures_supports_zero_conf"))) TS_NodeFeatures_supports_zero_conf(uint64_t this_arg) {
42196 LDKNodeFeatures this_arg_conv;
42197 this_arg_conv.inner = untag_ptr(this_arg);
42198 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42199 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42200 this_arg_conv.is_owned = false;
42201 jboolean ret_conv = NodeFeatures_supports_zero_conf(&this_arg_conv);
42205 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_optional"))) TS_ChannelTypeFeatures_set_zero_conf_optional(uint64_t this_arg) {
42206 LDKChannelTypeFeatures this_arg_conv;
42207 this_arg_conv.inner = untag_ptr(this_arg);
42208 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42210 this_arg_conv.is_owned = false;
42211 ChannelTypeFeatures_set_zero_conf_optional(&this_arg_conv);
42214 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_required"))) TS_ChannelTypeFeatures_set_zero_conf_required(uint64_t this_arg) {
42215 LDKChannelTypeFeatures this_arg_conv;
42216 this_arg_conv.inner = untag_ptr(this_arg);
42217 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42218 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42219 this_arg_conv.is_owned = false;
42220 ChannelTypeFeatures_set_zero_conf_required(&this_arg_conv);
42223 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_zero_conf"))) TS_ChannelTypeFeatures_supports_zero_conf(uint64_t this_arg) {
42224 LDKChannelTypeFeatures this_arg_conv;
42225 this_arg_conv.inner = untag_ptr(this_arg);
42226 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42228 this_arg_conv.is_owned = false;
42229 jboolean ret_conv = ChannelTypeFeatures_supports_zero_conf(&this_arg_conv);
42233 jboolean __attribute__((export_name("TS_InitFeatures_requires_zero_conf"))) TS_InitFeatures_requires_zero_conf(uint64_t this_arg) {
42234 LDKInitFeatures this_arg_conv;
42235 this_arg_conv.inner = untag_ptr(this_arg);
42236 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42238 this_arg_conv.is_owned = false;
42239 jboolean ret_conv = InitFeatures_requires_zero_conf(&this_arg_conv);
42243 jboolean __attribute__((export_name("TS_NodeFeatures_requires_zero_conf"))) TS_NodeFeatures_requires_zero_conf(uint64_t this_arg) {
42244 LDKNodeFeatures this_arg_conv;
42245 this_arg_conv.inner = untag_ptr(this_arg);
42246 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42248 this_arg_conv.is_owned = false;
42249 jboolean ret_conv = NodeFeatures_requires_zero_conf(&this_arg_conv);
42253 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_zero_conf"))) TS_ChannelTypeFeatures_requires_zero_conf(uint64_t this_arg) {
42254 LDKChannelTypeFeatures this_arg_conv;
42255 this_arg_conv.inner = untag_ptr(this_arg);
42256 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42258 this_arg_conv.is_owned = false;
42259 jboolean ret_conv = ChannelTypeFeatures_requires_zero_conf(&this_arg_conv);
42263 void __attribute__((export_name("TS_NodeFeatures_set_keysend_optional"))) TS_NodeFeatures_set_keysend_optional(uint64_t this_arg) {
42264 LDKNodeFeatures this_arg_conv;
42265 this_arg_conv.inner = untag_ptr(this_arg);
42266 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42268 this_arg_conv.is_owned = false;
42269 NodeFeatures_set_keysend_optional(&this_arg_conv);
42272 void __attribute__((export_name("TS_NodeFeatures_set_keysend_required"))) TS_NodeFeatures_set_keysend_required(uint64_t this_arg) {
42273 LDKNodeFeatures this_arg_conv;
42274 this_arg_conv.inner = untag_ptr(this_arg);
42275 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42277 this_arg_conv.is_owned = false;
42278 NodeFeatures_set_keysend_required(&this_arg_conv);
42281 jboolean __attribute__((export_name("TS_NodeFeatures_supports_keysend"))) TS_NodeFeatures_supports_keysend(uint64_t this_arg) {
42282 LDKNodeFeatures this_arg_conv;
42283 this_arg_conv.inner = untag_ptr(this_arg);
42284 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42285 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42286 this_arg_conv.is_owned = false;
42287 jboolean ret_conv = NodeFeatures_supports_keysend(&this_arg_conv);
42291 jboolean __attribute__((export_name("TS_NodeFeatures_requires_keysend"))) TS_NodeFeatures_requires_keysend(uint64_t this_arg) {
42292 LDKNodeFeatures this_arg_conv;
42293 this_arg_conv.inner = untag_ptr(this_arg);
42294 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42295 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42296 this_arg_conv.is_owned = false;
42297 jboolean ret_conv = NodeFeatures_requires_keysend(&this_arg_conv);
42301 void __attribute__((export_name("TS_ShutdownScript_free"))) TS_ShutdownScript_free(uint64_t this_obj) {
42302 LDKShutdownScript this_obj_conv;
42303 this_obj_conv.inner = untag_ptr(this_obj);
42304 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42306 ShutdownScript_free(this_obj_conv);
42309 static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
42310 LDKShutdownScript ret_var = ShutdownScript_clone(arg);
42311 uint64_t ret_ref = 0;
42312 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42313 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42316 int64_t __attribute__((export_name("TS_ShutdownScript_clone_ptr"))) TS_ShutdownScript_clone_ptr(uint64_t arg) {
42317 LDKShutdownScript arg_conv;
42318 arg_conv.inner = untag_ptr(arg);
42319 arg_conv.is_owned = ptr_is_owned(arg);
42320 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42321 arg_conv.is_owned = false;
42322 int64_t ret_conv = ShutdownScript_clone_ptr(&arg_conv);
42326 uint64_t __attribute__((export_name("TS_ShutdownScript_clone"))) TS_ShutdownScript_clone(uint64_t orig) {
42327 LDKShutdownScript orig_conv;
42328 orig_conv.inner = untag_ptr(orig);
42329 orig_conv.is_owned = ptr_is_owned(orig);
42330 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42331 orig_conv.is_owned = false;
42332 LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
42333 uint64_t ret_ref = 0;
42334 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42335 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42339 jboolean __attribute__((export_name("TS_ShutdownScript_eq"))) TS_ShutdownScript_eq(uint64_t a, uint64_t b) {
42340 LDKShutdownScript a_conv;
42341 a_conv.inner = untag_ptr(a);
42342 a_conv.is_owned = ptr_is_owned(a);
42343 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42344 a_conv.is_owned = false;
42345 LDKShutdownScript b_conv;
42346 b_conv.inner = untag_ptr(b);
42347 b_conv.is_owned = ptr_is_owned(b);
42348 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42349 b_conv.is_owned = false;
42350 jboolean ret_conv = ShutdownScript_eq(&a_conv, &b_conv);
42354 void __attribute__((export_name("TS_InvalidShutdownScript_free"))) TS_InvalidShutdownScript_free(uint64_t this_obj) {
42355 LDKInvalidShutdownScript this_obj_conv;
42356 this_obj_conv.inner = untag_ptr(this_obj);
42357 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42359 InvalidShutdownScript_free(this_obj_conv);
42362 int8_tArray __attribute__((export_name("TS_InvalidShutdownScript_get_script"))) TS_InvalidShutdownScript_get_script(uint64_t this_ptr) {
42363 LDKInvalidShutdownScript this_ptr_conv;
42364 this_ptr_conv.inner = untag_ptr(this_ptr);
42365 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42367 this_ptr_conv.is_owned = false;
42368 LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
42369 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42370 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42374 void __attribute__((export_name("TS_InvalidShutdownScript_set_script"))) TS_InvalidShutdownScript_set_script(uint64_t this_ptr, int8_tArray val) {
42375 LDKInvalidShutdownScript this_ptr_conv;
42376 this_ptr_conv.inner = untag_ptr(this_ptr);
42377 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42379 this_ptr_conv.is_owned = false;
42380 LDKCVec_u8Z val_ref;
42381 val_ref.datalen = val->arr_len;
42382 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
42383 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
42384 InvalidShutdownScript_set_script(&this_ptr_conv, val_ref);
42387 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_new"))) TS_InvalidShutdownScript_new(int8_tArray script_arg) {
42388 LDKCVec_u8Z script_arg_ref;
42389 script_arg_ref.datalen = script_arg->arr_len;
42390 script_arg_ref.data = MALLOC(script_arg_ref.datalen, "LDKCVec_u8Z Bytes");
42391 memcpy(script_arg_ref.data, script_arg->elems, script_arg_ref.datalen); FREE(script_arg);
42392 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_new(script_arg_ref);
42393 uint64_t ret_ref = 0;
42394 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42395 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42399 static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
42400 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
42401 uint64_t ret_ref = 0;
42402 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42403 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42406 int64_t __attribute__((export_name("TS_InvalidShutdownScript_clone_ptr"))) TS_InvalidShutdownScript_clone_ptr(uint64_t arg) {
42407 LDKInvalidShutdownScript arg_conv;
42408 arg_conv.inner = untag_ptr(arg);
42409 arg_conv.is_owned = ptr_is_owned(arg);
42410 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42411 arg_conv.is_owned = false;
42412 int64_t ret_conv = InvalidShutdownScript_clone_ptr(&arg_conv);
42416 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_clone"))) TS_InvalidShutdownScript_clone(uint64_t orig) {
42417 LDKInvalidShutdownScript orig_conv;
42418 orig_conv.inner = untag_ptr(orig);
42419 orig_conv.is_owned = ptr_is_owned(orig);
42420 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42421 orig_conv.is_owned = false;
42422 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
42423 uint64_t ret_ref = 0;
42424 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42425 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42429 int8_tArray __attribute__((export_name("TS_ShutdownScript_write"))) TS_ShutdownScript_write(uint64_t obj) {
42430 LDKShutdownScript obj_conv;
42431 obj_conv.inner = untag_ptr(obj);
42432 obj_conv.is_owned = ptr_is_owned(obj);
42433 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42434 obj_conv.is_owned = false;
42435 LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
42436 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42437 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42438 CVec_u8Z_free(ret_var);
42442 uint64_t __attribute__((export_name("TS_ShutdownScript_read"))) TS_ShutdownScript_read(int8_tArray ser) {
42443 LDKu8slice ser_ref;
42444 ser_ref.datalen = ser->arr_len;
42445 ser_ref.data = ser->elems;
42446 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
42447 *ret_conv = ShutdownScript_read(ser_ref);
42449 return tag_ptr(ret_conv, true);
42452 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wpkh"))) TS_ShutdownScript_new_p2wpkh(int8_tArray pubkey_hash) {
42453 uint8_t pubkey_hash_arr[20];
42454 CHECK(pubkey_hash->arr_len == 20);
42455 memcpy(pubkey_hash_arr, pubkey_hash->elems, 20); FREE(pubkey_hash);
42456 uint8_t (*pubkey_hash_ref)[20] = &pubkey_hash_arr;
42457 LDKShutdownScript ret_var = ShutdownScript_new_p2wpkh(pubkey_hash_ref);
42458 uint64_t ret_ref = 0;
42459 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42460 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42464 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wsh"))) TS_ShutdownScript_new_p2wsh(int8_tArray script_hash) {
42465 uint8_t script_hash_arr[32];
42466 CHECK(script_hash->arr_len == 32);
42467 memcpy(script_hash_arr, script_hash->elems, 32); FREE(script_hash);
42468 uint8_t (*script_hash_ref)[32] = &script_hash_arr;
42469 LDKShutdownScript ret_var = ShutdownScript_new_p2wsh(script_hash_ref);
42470 uint64_t ret_ref = 0;
42471 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42472 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42476 uint64_t __attribute__((export_name("TS_ShutdownScript_new_witness_program"))) TS_ShutdownScript_new_witness_program(int8_t version, int8_tArray program) {
42478 LDKu8slice program_ref;
42479 program_ref.datalen = program->arr_len;
42480 program_ref.data = program->elems;
42481 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
42482 *ret_conv = ShutdownScript_new_witness_program((LDKWitnessVersion){ ._0 = version }, program_ref);
42484 return tag_ptr(ret_conv, true);
42487 int8_tArray __attribute__((export_name("TS_ShutdownScript_into_inner"))) TS_ShutdownScript_into_inner(uint64_t this_arg) {
42488 LDKShutdownScript this_arg_conv;
42489 this_arg_conv.inner = untag_ptr(this_arg);
42490 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42492 this_arg_conv = ShutdownScript_clone(&this_arg_conv);
42493 LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
42494 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42495 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42496 CVec_u8Z_free(ret_var);
42500 int8_tArray __attribute__((export_name("TS_ShutdownScript_as_legacy_pubkey"))) TS_ShutdownScript_as_legacy_pubkey(uint64_t this_arg) {
42501 LDKShutdownScript this_arg_conv;
42502 this_arg_conv.inner = untag_ptr(this_arg);
42503 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42504 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42505 this_arg_conv.is_owned = false;
42506 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
42507 memcpy(ret_arr->elems, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
42511 jboolean __attribute__((export_name("TS_ShutdownScript_is_compatible"))) TS_ShutdownScript_is_compatible(uint64_t this_arg, uint64_t features) {
42512 LDKShutdownScript this_arg_conv;
42513 this_arg_conv.inner = untag_ptr(this_arg);
42514 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42516 this_arg_conv.is_owned = false;
42517 LDKInitFeatures features_conv;
42518 features_conv.inner = untag_ptr(features);
42519 features_conv.is_owned = ptr_is_owned(features);
42520 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
42521 features_conv.is_owned = false;
42522 jboolean ret_conv = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
42526 void __attribute__((export_name("TS_Retry_free"))) TS_Retry_free(uint64_t this_ptr) {
42527 if (!ptr_is_owned(this_ptr)) return;
42528 void* this_ptr_ptr = untag_ptr(this_ptr);
42529 CHECK_ACCESS(this_ptr_ptr);
42530 LDKRetry this_ptr_conv = *(LDKRetry*)(this_ptr_ptr);
42531 FREE(untag_ptr(this_ptr));
42532 Retry_free(this_ptr_conv);
42535 static inline uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg) {
42536 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
42537 *ret_copy = Retry_clone(arg);
42538 uint64_t ret_ref = tag_ptr(ret_copy, true);
42541 int64_t __attribute__((export_name("TS_Retry_clone_ptr"))) TS_Retry_clone_ptr(uint64_t arg) {
42542 LDKRetry* arg_conv = (LDKRetry*)untag_ptr(arg);
42543 int64_t ret_conv = Retry_clone_ptr(arg_conv);
42547 uint64_t __attribute__((export_name("TS_Retry_clone"))) TS_Retry_clone(uint64_t orig) {
42548 LDKRetry* orig_conv = (LDKRetry*)untag_ptr(orig);
42549 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
42550 *ret_copy = Retry_clone(orig_conv);
42551 uint64_t ret_ref = tag_ptr(ret_copy, true);
42555 uint64_t __attribute__((export_name("TS_Retry_attempts"))) TS_Retry_attempts(uint32_t a) {
42556 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
42557 *ret_copy = Retry_attempts(a);
42558 uint64_t ret_ref = tag_ptr(ret_copy, true);
42562 jboolean __attribute__((export_name("TS_Retry_eq"))) TS_Retry_eq(uint64_t a, uint64_t b) {
42563 LDKRetry* a_conv = (LDKRetry*)untag_ptr(a);
42564 LDKRetry* b_conv = (LDKRetry*)untag_ptr(b);
42565 jboolean ret_conv = Retry_eq(a_conv, b_conv);
42569 int64_t __attribute__((export_name("TS_Retry_hash"))) TS_Retry_hash(uint64_t o) {
42570 LDKRetry* o_conv = (LDKRetry*)untag_ptr(o);
42571 int64_t ret_conv = Retry_hash(o_conv);
42575 uint32_t __attribute__((export_name("TS_RetryableSendFailure_clone"))) TS_RetryableSendFailure_clone(uint64_t orig) {
42576 LDKRetryableSendFailure* orig_conv = (LDKRetryableSendFailure*)untag_ptr(orig);
42577 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_clone(orig_conv));
42581 uint32_t __attribute__((export_name("TS_RetryableSendFailure_payment_expired"))) TS_RetryableSendFailure_payment_expired() {
42582 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_payment_expired());
42586 uint32_t __attribute__((export_name("TS_RetryableSendFailure_route_not_found"))) TS_RetryableSendFailure_route_not_found() {
42587 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_route_not_found());
42591 uint32_t __attribute__((export_name("TS_RetryableSendFailure_duplicate_payment"))) TS_RetryableSendFailure_duplicate_payment() {
42592 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_duplicate_payment());
42596 void __attribute__((export_name("TS_PaymentSendFailure_free"))) TS_PaymentSendFailure_free(uint64_t this_ptr) {
42597 if (!ptr_is_owned(this_ptr)) return;
42598 void* this_ptr_ptr = untag_ptr(this_ptr);
42599 CHECK_ACCESS(this_ptr_ptr);
42600 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(this_ptr_ptr);
42601 FREE(untag_ptr(this_ptr));
42602 PaymentSendFailure_free(this_ptr_conv);
42605 static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
42606 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42607 *ret_copy = PaymentSendFailure_clone(arg);
42608 uint64_t ret_ref = tag_ptr(ret_copy, true);
42611 int64_t __attribute__((export_name("TS_PaymentSendFailure_clone_ptr"))) TS_PaymentSendFailure_clone_ptr(uint64_t arg) {
42612 LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)untag_ptr(arg);
42613 int64_t ret_conv = PaymentSendFailure_clone_ptr(arg_conv);
42617 uint64_t __attribute__((export_name("TS_PaymentSendFailure_clone"))) TS_PaymentSendFailure_clone(uint64_t orig) {
42618 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)untag_ptr(orig);
42619 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42620 *ret_copy = PaymentSendFailure_clone(orig_conv);
42621 uint64_t ret_ref = tag_ptr(ret_copy, true);
42625 uint64_t __attribute__((export_name("TS_PaymentSendFailure_parameter_error"))) TS_PaymentSendFailure_parameter_error(uint64_t a) {
42626 void* a_ptr = untag_ptr(a);
42627 CHECK_ACCESS(a_ptr);
42628 LDKAPIError a_conv = *(LDKAPIError*)(a_ptr);
42629 a_conv = APIError_clone((LDKAPIError*)untag_ptr(a));
42630 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42631 *ret_copy = PaymentSendFailure_parameter_error(a_conv);
42632 uint64_t ret_ref = tag_ptr(ret_copy, true);
42636 uint64_t __attribute__((export_name("TS_PaymentSendFailure_path_parameter_error"))) TS_PaymentSendFailure_path_parameter_error(uint64_tArray a) {
42637 LDKCVec_CResult_NoneAPIErrorZZ a_constr;
42638 a_constr.datalen = a->arr_len;
42639 if (a_constr.datalen > 0)
42640 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
42642 a_constr.data = NULL;
42643 uint64_t* a_vals = a->elems;
42644 for (size_t w = 0; w < a_constr.datalen; w++) {
42645 uint64_t a_conv_22 = a_vals[w];
42646 void* a_conv_22_ptr = untag_ptr(a_conv_22);
42647 CHECK_ACCESS(a_conv_22_ptr);
42648 LDKCResult_NoneAPIErrorZ a_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(a_conv_22_ptr);
42649 a_conv_22_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)untag_ptr(a_conv_22));
42650 a_constr.data[w] = a_conv_22_conv;
42653 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42654 *ret_copy = PaymentSendFailure_path_parameter_error(a_constr);
42655 uint64_t ret_ref = tag_ptr(ret_copy, true);
42659 uint64_t __attribute__((export_name("TS_PaymentSendFailure_all_failed_resend_safe"))) TS_PaymentSendFailure_all_failed_resend_safe(uint64_tArray a) {
42660 LDKCVec_APIErrorZ a_constr;
42661 a_constr.datalen = a->arr_len;
42662 if (a_constr.datalen > 0)
42663 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
42665 a_constr.data = NULL;
42666 uint64_t* a_vals = a->elems;
42667 for (size_t k = 0; k < a_constr.datalen; k++) {
42668 uint64_t a_conv_10 = a_vals[k];
42669 void* a_conv_10_ptr = untag_ptr(a_conv_10);
42670 CHECK_ACCESS(a_conv_10_ptr);
42671 LDKAPIError a_conv_10_conv = *(LDKAPIError*)(a_conv_10_ptr);
42672 a_conv_10_conv = APIError_clone((LDKAPIError*)untag_ptr(a_conv_10));
42673 a_constr.data[k] = a_conv_10_conv;
42676 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42677 *ret_copy = PaymentSendFailure_all_failed_resend_safe(a_constr);
42678 uint64_t ret_ref = tag_ptr(ret_copy, true);
42682 uint64_t __attribute__((export_name("TS_PaymentSendFailure_duplicate_payment"))) TS_PaymentSendFailure_duplicate_payment() {
42683 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42684 *ret_copy = PaymentSendFailure_duplicate_payment();
42685 uint64_t ret_ref = tag_ptr(ret_copy, true);
42689 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) {
42690 LDKCVec_CResult_NoneAPIErrorZZ results_constr;
42691 results_constr.datalen = results->arr_len;
42692 if (results_constr.datalen > 0)
42693 results_constr.data = MALLOC(results_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
42695 results_constr.data = NULL;
42696 uint64_t* results_vals = results->elems;
42697 for (size_t w = 0; w < results_constr.datalen; w++) {
42698 uint64_t results_conv_22 = results_vals[w];
42699 void* results_conv_22_ptr = untag_ptr(results_conv_22);
42700 CHECK_ACCESS(results_conv_22_ptr);
42701 LDKCResult_NoneAPIErrorZ results_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(results_conv_22_ptr);
42702 results_constr.data[w] = results_conv_22_conv;
42705 LDKRouteParameters failed_paths_retry_conv;
42706 failed_paths_retry_conv.inner = untag_ptr(failed_paths_retry);
42707 failed_paths_retry_conv.is_owned = ptr_is_owned(failed_paths_retry);
42708 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
42709 failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
42710 LDKThirtyTwoBytes payment_id_ref;
42711 CHECK(payment_id->arr_len == 32);
42712 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
42713 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
42714 *ret_copy = PaymentSendFailure_partial_failure(results_constr, failed_paths_retry_conv, payment_id_ref);
42715 uint64_t ret_ref = tag_ptr(ret_copy, true);
42719 void __attribute__((export_name("TS_RecipientOnionFields_free"))) TS_RecipientOnionFields_free(uint64_t this_obj) {
42720 LDKRecipientOnionFields this_obj_conv;
42721 this_obj_conv.inner = untag_ptr(this_obj);
42722 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42724 RecipientOnionFields_free(this_obj_conv);
42727 int8_tArray __attribute__((export_name("TS_RecipientOnionFields_get_payment_secret"))) TS_RecipientOnionFields_get_payment_secret(uint64_t this_ptr) {
42728 LDKRecipientOnionFields this_ptr_conv;
42729 this_ptr_conv.inner = untag_ptr(this_ptr);
42730 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42732 this_ptr_conv.is_owned = false;
42733 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
42734 memcpy(ret_arr->elems, RecipientOnionFields_get_payment_secret(&this_ptr_conv).data, 32);
42738 void __attribute__((export_name("TS_RecipientOnionFields_set_payment_secret"))) TS_RecipientOnionFields_set_payment_secret(uint64_t this_ptr, int8_tArray val) {
42739 LDKRecipientOnionFields this_ptr_conv;
42740 this_ptr_conv.inner = untag_ptr(this_ptr);
42741 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42742 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42743 this_ptr_conv.is_owned = false;
42744 LDKThirtyTwoBytes val_ref;
42745 CHECK(val->arr_len == 32);
42746 memcpy(val_ref.data, val->elems, 32); FREE(val);
42747 RecipientOnionFields_set_payment_secret(&this_ptr_conv, val_ref);
42750 uint64_t __attribute__((export_name("TS_RecipientOnionFields_get_payment_metadata"))) TS_RecipientOnionFields_get_payment_metadata(uint64_t this_ptr) {
42751 LDKRecipientOnionFields this_ptr_conv;
42752 this_ptr_conv.inner = untag_ptr(this_ptr);
42753 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42755 this_ptr_conv.is_owned = false;
42756 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
42757 *ret_copy = RecipientOnionFields_get_payment_metadata(&this_ptr_conv);
42758 uint64_t ret_ref = tag_ptr(ret_copy, true);
42762 void __attribute__((export_name("TS_RecipientOnionFields_set_payment_metadata"))) TS_RecipientOnionFields_set_payment_metadata(uint64_t this_ptr, uint64_t val) {
42763 LDKRecipientOnionFields this_ptr_conv;
42764 this_ptr_conv.inner = untag_ptr(this_ptr);
42765 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42767 this_ptr_conv.is_owned = false;
42768 void* val_ptr = untag_ptr(val);
42769 CHECK_ACCESS(val_ptr);
42770 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
42771 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
42772 RecipientOnionFields_set_payment_metadata(&this_ptr_conv, val_conv);
42775 uint64_t __attribute__((export_name("TS_RecipientOnionFields_new"))) TS_RecipientOnionFields_new(int8_tArray payment_secret_arg, uint64_t payment_metadata_arg) {
42776 LDKThirtyTwoBytes payment_secret_arg_ref;
42777 CHECK(payment_secret_arg->arr_len == 32);
42778 memcpy(payment_secret_arg_ref.data, payment_secret_arg->elems, 32); FREE(payment_secret_arg);
42779 void* payment_metadata_arg_ptr = untag_ptr(payment_metadata_arg);
42780 CHECK_ACCESS(payment_metadata_arg_ptr);
42781 LDKCOption_CVec_u8ZZ payment_metadata_arg_conv = *(LDKCOption_CVec_u8ZZ*)(payment_metadata_arg_ptr);
42782 payment_metadata_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(payment_metadata_arg));
42783 LDKRecipientOnionFields ret_var = RecipientOnionFields_new(payment_secret_arg_ref, payment_metadata_arg_conv);
42784 uint64_t ret_ref = 0;
42785 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42786 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42790 static inline uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg) {
42791 LDKRecipientOnionFields ret_var = RecipientOnionFields_clone(arg);
42792 uint64_t ret_ref = 0;
42793 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42794 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42797 int64_t __attribute__((export_name("TS_RecipientOnionFields_clone_ptr"))) TS_RecipientOnionFields_clone_ptr(uint64_t arg) {
42798 LDKRecipientOnionFields arg_conv;
42799 arg_conv.inner = untag_ptr(arg);
42800 arg_conv.is_owned = ptr_is_owned(arg);
42801 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42802 arg_conv.is_owned = false;
42803 int64_t ret_conv = RecipientOnionFields_clone_ptr(&arg_conv);
42807 uint64_t __attribute__((export_name("TS_RecipientOnionFields_clone"))) TS_RecipientOnionFields_clone(uint64_t orig) {
42808 LDKRecipientOnionFields orig_conv;
42809 orig_conv.inner = untag_ptr(orig);
42810 orig_conv.is_owned = ptr_is_owned(orig);
42811 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42812 orig_conv.is_owned = false;
42813 LDKRecipientOnionFields ret_var = RecipientOnionFields_clone(&orig_conv);
42814 uint64_t ret_ref = 0;
42815 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42816 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42820 jboolean __attribute__((export_name("TS_RecipientOnionFields_eq"))) TS_RecipientOnionFields_eq(uint64_t a, uint64_t b) {
42821 LDKRecipientOnionFields a_conv;
42822 a_conv.inner = untag_ptr(a);
42823 a_conv.is_owned = ptr_is_owned(a);
42824 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42825 a_conv.is_owned = false;
42826 LDKRecipientOnionFields b_conv;
42827 b_conv.inner = untag_ptr(b);
42828 b_conv.is_owned = ptr_is_owned(b);
42829 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42830 b_conv.is_owned = false;
42831 jboolean ret_conv = RecipientOnionFields_eq(&a_conv, &b_conv);
42835 int8_tArray __attribute__((export_name("TS_RecipientOnionFields_write"))) TS_RecipientOnionFields_write(uint64_t obj) {
42836 LDKRecipientOnionFields obj_conv;
42837 obj_conv.inner = untag_ptr(obj);
42838 obj_conv.is_owned = ptr_is_owned(obj);
42839 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42840 obj_conv.is_owned = false;
42841 LDKCVec_u8Z ret_var = RecipientOnionFields_write(&obj_conv);
42842 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42843 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42844 CVec_u8Z_free(ret_var);
42848 uint64_t __attribute__((export_name("TS_RecipientOnionFields_read"))) TS_RecipientOnionFields_read(int8_tArray ser) {
42849 LDKu8slice ser_ref;
42850 ser_ref.datalen = ser->arr_len;
42851 ser_ref.data = ser->elems;
42852 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
42853 *ret_conv = RecipientOnionFields_read(ser_ref);
42855 return tag_ptr(ret_conv, true);
42858 uint64_t __attribute__((export_name("TS_RecipientOnionFields_secret_only"))) TS_RecipientOnionFields_secret_only(int8_tArray payment_secret) {
42859 LDKThirtyTwoBytes payment_secret_ref;
42860 CHECK(payment_secret->arr_len == 32);
42861 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
42862 LDKRecipientOnionFields ret_var = RecipientOnionFields_secret_only(payment_secret_ref);
42863 uint64_t ret_ref = 0;
42864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42865 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42869 uint64_t __attribute__((export_name("TS_RecipientOnionFields_spontaneous_empty"))) TS_RecipientOnionFields_spontaneous_empty() {
42870 LDKRecipientOnionFields ret_var = RecipientOnionFields_spontaneous_empty();
42871 uint64_t ret_ref = 0;
42872 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42873 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42877 void __attribute__((export_name("TS_CustomMessageReader_free"))) TS_CustomMessageReader_free(uint64_t this_ptr) {
42878 if (!ptr_is_owned(this_ptr)) return;
42879 void* this_ptr_ptr = untag_ptr(this_ptr);
42880 CHECK_ACCESS(this_ptr_ptr);
42881 LDKCustomMessageReader this_ptr_conv = *(LDKCustomMessageReader*)(this_ptr_ptr);
42882 FREE(untag_ptr(this_ptr));
42883 CustomMessageReader_free(this_ptr_conv);
42886 static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
42887 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
42888 *ret_ret = Type_clone(arg);
42889 return tag_ptr(ret_ret, true);
42891 int64_t __attribute__((export_name("TS_Type_clone_ptr"))) TS_Type_clone_ptr(uint64_t arg) {
42892 void* arg_ptr = untag_ptr(arg);
42893 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
42894 LDKType* arg_conv = (LDKType*)arg_ptr;
42895 int64_t ret_conv = Type_clone_ptr(arg_conv);
42899 uint64_t __attribute__((export_name("TS_Type_clone"))) TS_Type_clone(uint64_t orig) {
42900 void* orig_ptr = untag_ptr(orig);
42901 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
42902 LDKType* orig_conv = (LDKType*)orig_ptr;
42903 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
42904 *ret_ret = Type_clone(orig_conv);
42905 return tag_ptr(ret_ret, true);
42908 void __attribute__((export_name("TS_Type_free"))) TS_Type_free(uint64_t this_ptr) {
42909 if (!ptr_is_owned(this_ptr)) return;
42910 void* this_ptr_ptr = untag_ptr(this_ptr);
42911 CHECK_ACCESS(this_ptr_ptr);
42912 LDKType this_ptr_conv = *(LDKType*)(this_ptr_ptr);
42913 FREE(untag_ptr(this_ptr));
42914 Type_free(this_ptr_conv);
42917 void __attribute__((export_name("TS_UnsignedInvoice_free"))) TS_UnsignedInvoice_free(uint64_t this_obj) {
42918 LDKUnsignedInvoice this_obj_conv;
42919 this_obj_conv.inner = untag_ptr(this_obj);
42920 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42921 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42922 UnsignedInvoice_free(this_obj_conv);
42925 int8_tArray __attribute__((export_name("TS_UnsignedInvoice_signing_pubkey"))) TS_UnsignedInvoice_signing_pubkey(uint64_t this_arg) {
42926 LDKUnsignedInvoice this_arg_conv;
42927 this_arg_conv.inner = untag_ptr(this_arg);
42928 this_arg_conv.is_owned = ptr_is_owned(this_arg);
42929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42930 this_arg_conv.is_owned = false;
42931 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
42932 memcpy(ret_arr->elems, UnsignedInvoice_signing_pubkey(&this_arg_conv).compressed_form, 33);
42936 void __attribute__((export_name("TS_BlindedPayInfo_free"))) TS_BlindedPayInfo_free(uint64_t this_obj) {
42937 LDKBlindedPayInfo this_obj_conv;
42938 this_obj_conv.inner = untag_ptr(this_obj);
42939 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42941 BlindedPayInfo_free(this_obj_conv);
42944 int32_t __attribute__((export_name("TS_BlindedPayInfo_get_fee_base_msat"))) TS_BlindedPayInfo_get_fee_base_msat(uint64_t this_ptr) {
42945 LDKBlindedPayInfo this_ptr_conv;
42946 this_ptr_conv.inner = untag_ptr(this_ptr);
42947 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42948 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42949 this_ptr_conv.is_owned = false;
42950 int32_t ret_conv = BlindedPayInfo_get_fee_base_msat(&this_ptr_conv);
42954 void __attribute__((export_name("TS_BlindedPayInfo_set_fee_base_msat"))) TS_BlindedPayInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
42955 LDKBlindedPayInfo this_ptr_conv;
42956 this_ptr_conv.inner = untag_ptr(this_ptr);
42957 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42959 this_ptr_conv.is_owned = false;
42960 BlindedPayInfo_set_fee_base_msat(&this_ptr_conv, val);
42963 int32_t __attribute__((export_name("TS_BlindedPayInfo_get_fee_proportional_millionths"))) TS_BlindedPayInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
42964 LDKBlindedPayInfo this_ptr_conv;
42965 this_ptr_conv.inner = untag_ptr(this_ptr);
42966 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42968 this_ptr_conv.is_owned = false;
42969 int32_t ret_conv = BlindedPayInfo_get_fee_proportional_millionths(&this_ptr_conv);
42973 void __attribute__((export_name("TS_BlindedPayInfo_set_fee_proportional_millionths"))) TS_BlindedPayInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
42974 LDKBlindedPayInfo this_ptr_conv;
42975 this_ptr_conv.inner = untag_ptr(this_ptr);
42976 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42978 this_ptr_conv.is_owned = false;
42979 BlindedPayInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
42982 int16_t __attribute__((export_name("TS_BlindedPayInfo_get_cltv_expiry_delta"))) TS_BlindedPayInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
42983 LDKBlindedPayInfo this_ptr_conv;
42984 this_ptr_conv.inner = untag_ptr(this_ptr);
42985 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42986 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42987 this_ptr_conv.is_owned = false;
42988 int16_t ret_conv = BlindedPayInfo_get_cltv_expiry_delta(&this_ptr_conv);
42992 void __attribute__((export_name("TS_BlindedPayInfo_set_cltv_expiry_delta"))) TS_BlindedPayInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
42993 LDKBlindedPayInfo this_ptr_conv;
42994 this_ptr_conv.inner = untag_ptr(this_ptr);
42995 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42997 this_ptr_conv.is_owned = false;
42998 BlindedPayInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
43001 int64_t __attribute__((export_name("TS_BlindedPayInfo_get_htlc_minimum_msat"))) TS_BlindedPayInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
43002 LDKBlindedPayInfo this_ptr_conv;
43003 this_ptr_conv.inner = untag_ptr(this_ptr);
43004 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43006 this_ptr_conv.is_owned = false;
43007 int64_t ret_conv = BlindedPayInfo_get_htlc_minimum_msat(&this_ptr_conv);
43011 void __attribute__((export_name("TS_BlindedPayInfo_set_htlc_minimum_msat"))) TS_BlindedPayInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
43012 LDKBlindedPayInfo this_ptr_conv;
43013 this_ptr_conv.inner = untag_ptr(this_ptr);
43014 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43016 this_ptr_conv.is_owned = false;
43017 BlindedPayInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
43020 int64_t __attribute__((export_name("TS_BlindedPayInfo_get_htlc_maximum_msat"))) TS_BlindedPayInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
43021 LDKBlindedPayInfo this_ptr_conv;
43022 this_ptr_conv.inner = untag_ptr(this_ptr);
43023 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43025 this_ptr_conv.is_owned = false;
43026 int64_t ret_conv = BlindedPayInfo_get_htlc_maximum_msat(&this_ptr_conv);
43030 void __attribute__((export_name("TS_BlindedPayInfo_set_htlc_maximum_msat"))) TS_BlindedPayInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
43031 LDKBlindedPayInfo this_ptr_conv;
43032 this_ptr_conv.inner = untag_ptr(this_ptr);
43033 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43035 this_ptr_conv.is_owned = false;
43036 BlindedPayInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
43039 uint64_t __attribute__((export_name("TS_BlindedPayInfo_get_features"))) TS_BlindedPayInfo_get_features(uint64_t this_ptr) {
43040 LDKBlindedPayInfo this_ptr_conv;
43041 this_ptr_conv.inner = untag_ptr(this_ptr);
43042 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43043 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43044 this_ptr_conv.is_owned = false;
43045 LDKBlindedHopFeatures ret_var = BlindedPayInfo_get_features(&this_ptr_conv);
43046 uint64_t ret_ref = 0;
43047 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43048 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43052 void __attribute__((export_name("TS_BlindedPayInfo_set_features"))) TS_BlindedPayInfo_set_features(uint64_t this_ptr, uint64_t val) {
43053 LDKBlindedPayInfo this_ptr_conv;
43054 this_ptr_conv.inner = untag_ptr(this_ptr);
43055 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43057 this_ptr_conv.is_owned = false;
43058 LDKBlindedHopFeatures val_conv;
43059 val_conv.inner = untag_ptr(val);
43060 val_conv.is_owned = ptr_is_owned(val);
43061 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43062 val_conv = BlindedHopFeatures_clone(&val_conv);
43063 BlindedPayInfo_set_features(&this_ptr_conv, val_conv);
43066 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) {
43067 LDKBlindedHopFeatures features_arg_conv;
43068 features_arg_conv.inner = untag_ptr(features_arg);
43069 features_arg_conv.is_owned = ptr_is_owned(features_arg);
43070 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
43071 features_arg_conv = BlindedHopFeatures_clone(&features_arg_conv);
43072 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);
43073 uint64_t ret_ref = 0;
43074 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43075 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43079 static inline uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg) {
43080 LDKBlindedPayInfo ret_var = BlindedPayInfo_clone(arg);
43081 uint64_t ret_ref = 0;
43082 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43083 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43086 int64_t __attribute__((export_name("TS_BlindedPayInfo_clone_ptr"))) TS_BlindedPayInfo_clone_ptr(uint64_t arg) {
43087 LDKBlindedPayInfo arg_conv;
43088 arg_conv.inner = untag_ptr(arg);
43089 arg_conv.is_owned = ptr_is_owned(arg);
43090 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43091 arg_conv.is_owned = false;
43092 int64_t ret_conv = BlindedPayInfo_clone_ptr(&arg_conv);
43096 uint64_t __attribute__((export_name("TS_BlindedPayInfo_clone"))) TS_BlindedPayInfo_clone(uint64_t orig) {
43097 LDKBlindedPayInfo orig_conv;
43098 orig_conv.inner = untag_ptr(orig);
43099 orig_conv.is_owned = ptr_is_owned(orig);
43100 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43101 orig_conv.is_owned = false;
43102 LDKBlindedPayInfo ret_var = BlindedPayInfo_clone(&orig_conv);
43103 uint64_t ret_ref = 0;
43104 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43105 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43109 int64_t __attribute__((export_name("TS_BlindedPayInfo_hash"))) TS_BlindedPayInfo_hash(uint64_t o) {
43110 LDKBlindedPayInfo o_conv;
43111 o_conv.inner = untag_ptr(o);
43112 o_conv.is_owned = ptr_is_owned(o);
43113 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
43114 o_conv.is_owned = false;
43115 int64_t ret_conv = BlindedPayInfo_hash(&o_conv);
43119 jboolean __attribute__((export_name("TS_BlindedPayInfo_eq"))) TS_BlindedPayInfo_eq(uint64_t a, uint64_t b) {
43120 LDKBlindedPayInfo a_conv;
43121 a_conv.inner = untag_ptr(a);
43122 a_conv.is_owned = ptr_is_owned(a);
43123 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43124 a_conv.is_owned = false;
43125 LDKBlindedPayInfo b_conv;
43126 b_conv.inner = untag_ptr(b);
43127 b_conv.is_owned = ptr_is_owned(b);
43128 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43129 b_conv.is_owned = false;
43130 jboolean ret_conv = BlindedPayInfo_eq(&a_conv, &b_conv);
43134 int8_tArray __attribute__((export_name("TS_BlindedPayInfo_write"))) TS_BlindedPayInfo_write(uint64_t obj) {
43135 LDKBlindedPayInfo obj_conv;
43136 obj_conv.inner = untag_ptr(obj);
43137 obj_conv.is_owned = ptr_is_owned(obj);
43138 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43139 obj_conv.is_owned = false;
43140 LDKCVec_u8Z ret_var = BlindedPayInfo_write(&obj_conv);
43141 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43142 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43143 CVec_u8Z_free(ret_var);
43147 uint64_t __attribute__((export_name("TS_BlindedPayInfo_read"))) TS_BlindedPayInfo_read(int8_tArray ser) {
43148 LDKu8slice ser_ref;
43149 ser_ref.datalen = ser->arr_len;
43150 ser_ref.data = ser->elems;
43151 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
43152 *ret_conv = BlindedPayInfo_read(ser_ref);
43154 return tag_ptr(ret_conv, true);
43157 void __attribute__((export_name("TS_UnsignedInvoiceRequest_free"))) TS_UnsignedInvoiceRequest_free(uint64_t this_obj) {
43158 LDKUnsignedInvoiceRequest this_obj_conv;
43159 this_obj_conv.inner = untag_ptr(this_obj);
43160 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43162 UnsignedInvoiceRequest_free(this_obj_conv);
43165 void __attribute__((export_name("TS_InvoiceRequest_free"))) TS_InvoiceRequest_free(uint64_t this_obj) {
43166 LDKInvoiceRequest this_obj_conv;
43167 this_obj_conv.inner = untag_ptr(this_obj);
43168 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43170 InvoiceRequest_free(this_obj_conv);
43173 static inline uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg) {
43174 LDKInvoiceRequest ret_var = InvoiceRequest_clone(arg);
43175 uint64_t ret_ref = 0;
43176 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43177 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43180 int64_t __attribute__((export_name("TS_InvoiceRequest_clone_ptr"))) TS_InvoiceRequest_clone_ptr(uint64_t arg) {
43181 LDKInvoiceRequest arg_conv;
43182 arg_conv.inner = untag_ptr(arg);
43183 arg_conv.is_owned = ptr_is_owned(arg);
43184 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43185 arg_conv.is_owned = false;
43186 int64_t ret_conv = InvoiceRequest_clone_ptr(&arg_conv);
43190 uint64_t __attribute__((export_name("TS_InvoiceRequest_clone"))) TS_InvoiceRequest_clone(uint64_t orig) {
43191 LDKInvoiceRequest orig_conv;
43192 orig_conv.inner = untag_ptr(orig);
43193 orig_conv.is_owned = ptr_is_owned(orig);
43194 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43195 orig_conv.is_owned = false;
43196 LDKInvoiceRequest ret_var = InvoiceRequest_clone(&orig_conv);
43197 uint64_t ret_ref = 0;
43198 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43199 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43203 int8_tArray __attribute__((export_name("TS_InvoiceRequest_metadata"))) TS_InvoiceRequest_metadata(uint64_t this_arg) {
43204 LDKInvoiceRequest this_arg_conv;
43205 this_arg_conv.inner = untag_ptr(this_arg);
43206 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43208 this_arg_conv.is_owned = false;
43209 LDKu8slice ret_var = InvoiceRequest_metadata(&this_arg_conv);
43210 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43211 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43215 int8_tArray __attribute__((export_name("TS_InvoiceRequest_chain"))) TS_InvoiceRequest_chain(uint64_t this_arg) {
43216 LDKInvoiceRequest this_arg_conv;
43217 this_arg_conv.inner = untag_ptr(this_arg);
43218 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43220 this_arg_conv.is_owned = false;
43221 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43222 memcpy(ret_arr->elems, InvoiceRequest_chain(&this_arg_conv).data, 32);
43226 uint64_t __attribute__((export_name("TS_InvoiceRequest_amount_msats"))) TS_InvoiceRequest_amount_msats(uint64_t this_arg) {
43227 LDKInvoiceRequest this_arg_conv;
43228 this_arg_conv.inner = untag_ptr(this_arg);
43229 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43231 this_arg_conv.is_owned = false;
43232 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43233 *ret_copy = InvoiceRequest_amount_msats(&this_arg_conv);
43234 uint64_t ret_ref = tag_ptr(ret_copy, true);
43238 uint64_t __attribute__((export_name("TS_InvoiceRequest_features"))) TS_InvoiceRequest_features(uint64_t this_arg) {
43239 LDKInvoiceRequest this_arg_conv;
43240 this_arg_conv.inner = untag_ptr(this_arg);
43241 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43243 this_arg_conv.is_owned = false;
43244 LDKInvoiceRequestFeatures ret_var = InvoiceRequest_features(&this_arg_conv);
43245 uint64_t ret_ref = 0;
43246 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43247 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43251 uint64_t __attribute__((export_name("TS_InvoiceRequest_quantity"))) TS_InvoiceRequest_quantity(uint64_t this_arg) {
43252 LDKInvoiceRequest this_arg_conv;
43253 this_arg_conv.inner = untag_ptr(this_arg);
43254 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43256 this_arg_conv.is_owned = false;
43257 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43258 *ret_copy = InvoiceRequest_quantity(&this_arg_conv);
43259 uint64_t ret_ref = tag_ptr(ret_copy, true);
43263 int8_tArray __attribute__((export_name("TS_InvoiceRequest_payer_id"))) TS_InvoiceRequest_payer_id(uint64_t this_arg) {
43264 LDKInvoiceRequest this_arg_conv;
43265 this_arg_conv.inner = untag_ptr(this_arg);
43266 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43268 this_arg_conv.is_owned = false;
43269 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43270 memcpy(ret_arr->elems, InvoiceRequest_payer_id(&this_arg_conv).compressed_form, 33);
43274 uint64_t __attribute__((export_name("TS_InvoiceRequest_payer_note"))) TS_InvoiceRequest_payer_note(uint64_t this_arg) {
43275 LDKInvoiceRequest this_arg_conv;
43276 this_arg_conv.inner = untag_ptr(this_arg);
43277 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43279 this_arg_conv.is_owned = false;
43280 LDKPrintableString ret_var = InvoiceRequest_payer_note(&this_arg_conv);
43281 uint64_t ret_ref = 0;
43282 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43283 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43287 int8_tArray __attribute__((export_name("TS_InvoiceRequest_write"))) TS_InvoiceRequest_write(uint64_t obj) {
43288 LDKInvoiceRequest obj_conv;
43289 obj_conv.inner = untag_ptr(obj);
43290 obj_conv.is_owned = ptr_is_owned(obj);
43291 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43292 obj_conv.is_owned = false;
43293 LDKCVec_u8Z ret_var = InvoiceRequest_write(&obj_conv);
43294 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43295 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43296 CVec_u8Z_free(ret_var);
43300 void __attribute__((export_name("TS_Offer_free"))) TS_Offer_free(uint64_t this_obj) {
43301 LDKOffer this_obj_conv;
43302 this_obj_conv.inner = untag_ptr(this_obj);
43303 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43305 Offer_free(this_obj_conv);
43308 static inline uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg) {
43309 LDKOffer ret_var = Offer_clone(arg);
43310 uint64_t ret_ref = 0;
43311 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43312 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43315 int64_t __attribute__((export_name("TS_Offer_clone_ptr"))) TS_Offer_clone_ptr(uint64_t arg) {
43317 arg_conv.inner = untag_ptr(arg);
43318 arg_conv.is_owned = ptr_is_owned(arg);
43319 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43320 arg_conv.is_owned = false;
43321 int64_t ret_conv = Offer_clone_ptr(&arg_conv);
43325 uint64_t __attribute__((export_name("TS_Offer_clone"))) TS_Offer_clone(uint64_t orig) {
43326 LDKOffer orig_conv;
43327 orig_conv.inner = untag_ptr(orig);
43328 orig_conv.is_owned = ptr_is_owned(orig);
43329 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43330 orig_conv.is_owned = false;
43331 LDKOffer ret_var = Offer_clone(&orig_conv);
43332 uint64_t ret_ref = 0;
43333 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43334 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43338 ptrArray __attribute__((export_name("TS_Offer_chains"))) TS_Offer_chains(uint64_t this_arg) {
43339 LDKOffer this_arg_conv;
43340 this_arg_conv.inner = untag_ptr(this_arg);
43341 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43342 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43343 this_arg_conv.is_owned = false;
43344 LDKCVec_ChainHashZ ret_var = Offer_chains(&this_arg_conv);
43345 ptrArray ret_arr = NULL;
43346 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
43347 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
43348 for (size_t m = 0; m < ret_var.datalen; m++) {
43349 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
43350 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
43351 ret_arr_ptr[m] = ret_conv_12_arr;
43354 FREE(ret_var.data);
43358 jboolean __attribute__((export_name("TS_Offer_supports_chain"))) TS_Offer_supports_chain(uint64_t this_arg, int8_tArray chain) {
43359 LDKOffer this_arg_conv;
43360 this_arg_conv.inner = untag_ptr(this_arg);
43361 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43363 this_arg_conv.is_owned = false;
43364 LDKThirtyTwoBytes chain_ref;
43365 CHECK(chain->arr_len == 32);
43366 memcpy(chain_ref.data, chain->elems, 32); FREE(chain);
43367 jboolean ret_conv = Offer_supports_chain(&this_arg_conv, chain_ref);
43371 uint64_t __attribute__((export_name("TS_Offer_metadata"))) TS_Offer_metadata(uint64_t this_arg) {
43372 LDKOffer this_arg_conv;
43373 this_arg_conv.inner = untag_ptr(this_arg);
43374 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43376 this_arg_conv.is_owned = false;
43377 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
43378 *ret_copy = Offer_metadata(&this_arg_conv);
43379 uint64_t ret_ref = tag_ptr(ret_copy, true);
43383 uint64_t __attribute__((export_name("TS_Offer_amount"))) TS_Offer_amount(uint64_t this_arg) {
43384 LDKOffer this_arg_conv;
43385 this_arg_conv.inner = untag_ptr(this_arg);
43386 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43388 this_arg_conv.is_owned = false;
43389 LDKAmount ret_var = Offer_amount(&this_arg_conv);
43390 uint64_t ret_ref = 0;
43391 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43392 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43396 uint64_t __attribute__((export_name("TS_Offer_description"))) TS_Offer_description(uint64_t this_arg) {
43397 LDKOffer this_arg_conv;
43398 this_arg_conv.inner = untag_ptr(this_arg);
43399 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43401 this_arg_conv.is_owned = false;
43402 LDKPrintableString ret_var = Offer_description(&this_arg_conv);
43403 uint64_t ret_ref = 0;
43404 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43405 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43409 uint64_t __attribute__((export_name("TS_Offer_features"))) TS_Offer_features(uint64_t this_arg) {
43410 LDKOffer this_arg_conv;
43411 this_arg_conv.inner = untag_ptr(this_arg);
43412 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43414 this_arg_conv.is_owned = false;
43415 LDKOfferFeatures ret_var = Offer_features(&this_arg_conv);
43416 uint64_t ret_ref = 0;
43417 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43418 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43422 uint64_t __attribute__((export_name("TS_Offer_absolute_expiry"))) TS_Offer_absolute_expiry(uint64_t this_arg) {
43423 LDKOffer this_arg_conv;
43424 this_arg_conv.inner = untag_ptr(this_arg);
43425 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43427 this_arg_conv.is_owned = false;
43428 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
43429 *ret_copy = Offer_absolute_expiry(&this_arg_conv);
43430 uint64_t ret_ref = tag_ptr(ret_copy, true);
43434 uint64_t __attribute__((export_name("TS_Offer_issuer"))) TS_Offer_issuer(uint64_t this_arg) {
43435 LDKOffer this_arg_conv;
43436 this_arg_conv.inner = untag_ptr(this_arg);
43437 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43439 this_arg_conv.is_owned = false;
43440 LDKPrintableString ret_var = Offer_issuer(&this_arg_conv);
43441 uint64_t ret_ref = 0;
43442 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43443 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43447 uint64_tArray __attribute__((export_name("TS_Offer_paths"))) TS_Offer_paths(uint64_t this_arg) {
43448 LDKOffer this_arg_conv;
43449 this_arg_conv.inner = untag_ptr(this_arg);
43450 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43452 this_arg_conv.is_owned = false;
43453 LDKCVec_BlindedPathZ ret_var = Offer_paths(&this_arg_conv);
43454 uint64_tArray ret_arr = NULL;
43455 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
43456 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
43457 for (size_t n = 0; n < ret_var.datalen; n++) {
43458 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
43459 uint64_t ret_conv_13_ref = 0;
43460 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
43461 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
43462 ret_arr_ptr[n] = ret_conv_13_ref;
43465 FREE(ret_var.data);
43469 uint64_t __attribute__((export_name("TS_Offer_supported_quantity"))) TS_Offer_supported_quantity(uint64_t this_arg) {
43470 LDKOffer this_arg_conv;
43471 this_arg_conv.inner = untag_ptr(this_arg);
43472 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43473 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43474 this_arg_conv.is_owned = false;
43475 LDKQuantity ret_var = Offer_supported_quantity(&this_arg_conv);
43476 uint64_t ret_ref = 0;
43477 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43478 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43482 jboolean __attribute__((export_name("TS_Offer_is_valid_quantity"))) TS_Offer_is_valid_quantity(uint64_t this_arg, int64_t quantity) {
43483 LDKOffer this_arg_conv;
43484 this_arg_conv.inner = untag_ptr(this_arg);
43485 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43487 this_arg_conv.is_owned = false;
43488 jboolean ret_conv = Offer_is_valid_quantity(&this_arg_conv, quantity);
43492 jboolean __attribute__((export_name("TS_Offer_expects_quantity"))) TS_Offer_expects_quantity(uint64_t this_arg) {
43493 LDKOffer this_arg_conv;
43494 this_arg_conv.inner = untag_ptr(this_arg);
43495 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43497 this_arg_conv.is_owned = false;
43498 jboolean ret_conv = Offer_expects_quantity(&this_arg_conv);
43502 int8_tArray __attribute__((export_name("TS_Offer_signing_pubkey"))) TS_Offer_signing_pubkey(uint64_t this_arg) {
43503 LDKOffer this_arg_conv;
43504 this_arg_conv.inner = untag_ptr(this_arg);
43505 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43507 this_arg_conv.is_owned = false;
43508 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43509 memcpy(ret_arr->elems, Offer_signing_pubkey(&this_arg_conv).compressed_form, 33);
43513 int8_tArray __attribute__((export_name("TS_Offer_write"))) TS_Offer_write(uint64_t obj) {
43515 obj_conv.inner = untag_ptr(obj);
43516 obj_conv.is_owned = ptr_is_owned(obj);
43517 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43518 obj_conv.is_owned = false;
43519 LDKCVec_u8Z ret_var = Offer_write(&obj_conv);
43520 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43521 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43522 CVec_u8Z_free(ret_var);
43526 void __attribute__((export_name("TS_Amount_free"))) TS_Amount_free(uint64_t this_obj) {
43527 LDKAmount this_obj_conv;
43528 this_obj_conv.inner = untag_ptr(this_obj);
43529 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43531 Amount_free(this_obj_conv);
43534 static inline uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg) {
43535 LDKAmount ret_var = Amount_clone(arg);
43536 uint64_t ret_ref = 0;
43537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43541 int64_t __attribute__((export_name("TS_Amount_clone_ptr"))) TS_Amount_clone_ptr(uint64_t arg) {
43542 LDKAmount arg_conv;
43543 arg_conv.inner = untag_ptr(arg);
43544 arg_conv.is_owned = ptr_is_owned(arg);
43545 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43546 arg_conv.is_owned = false;
43547 int64_t ret_conv = Amount_clone_ptr(&arg_conv);
43551 uint64_t __attribute__((export_name("TS_Amount_clone"))) TS_Amount_clone(uint64_t orig) {
43552 LDKAmount orig_conv;
43553 orig_conv.inner = untag_ptr(orig);
43554 orig_conv.is_owned = ptr_is_owned(orig);
43555 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43556 orig_conv.is_owned = false;
43557 LDKAmount ret_var = Amount_clone(&orig_conv);
43558 uint64_t ret_ref = 0;
43559 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43560 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43564 void __attribute__((export_name("TS_Quantity_free"))) TS_Quantity_free(uint64_t this_obj) {
43565 LDKQuantity this_obj_conv;
43566 this_obj_conv.inner = untag_ptr(this_obj);
43567 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43569 Quantity_free(this_obj_conv);
43572 static inline uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg) {
43573 LDKQuantity ret_var = Quantity_clone(arg);
43574 uint64_t ret_ref = 0;
43575 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43576 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43579 int64_t __attribute__((export_name("TS_Quantity_clone_ptr"))) TS_Quantity_clone_ptr(uint64_t arg) {
43580 LDKQuantity arg_conv;
43581 arg_conv.inner = untag_ptr(arg);
43582 arg_conv.is_owned = ptr_is_owned(arg);
43583 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43584 arg_conv.is_owned = false;
43585 int64_t ret_conv = Quantity_clone_ptr(&arg_conv);
43589 uint64_t __attribute__((export_name("TS_Quantity_clone"))) TS_Quantity_clone(uint64_t orig) {
43590 LDKQuantity orig_conv;
43591 orig_conv.inner = untag_ptr(orig);
43592 orig_conv.is_owned = ptr_is_owned(orig);
43593 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43594 orig_conv.is_owned = false;
43595 LDKQuantity ret_var = Quantity_clone(&orig_conv);
43596 uint64_t ret_ref = 0;
43597 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43598 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43602 void __attribute__((export_name("TS_Refund_free"))) TS_Refund_free(uint64_t this_obj) {
43603 LDKRefund this_obj_conv;
43604 this_obj_conv.inner = untag_ptr(this_obj);
43605 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43607 Refund_free(this_obj_conv);
43610 static inline uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg) {
43611 LDKRefund ret_var = Refund_clone(arg);
43612 uint64_t ret_ref = 0;
43613 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43614 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43617 int64_t __attribute__((export_name("TS_Refund_clone_ptr"))) TS_Refund_clone_ptr(uint64_t arg) {
43618 LDKRefund arg_conv;
43619 arg_conv.inner = untag_ptr(arg);
43620 arg_conv.is_owned = ptr_is_owned(arg);
43621 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43622 arg_conv.is_owned = false;
43623 int64_t ret_conv = Refund_clone_ptr(&arg_conv);
43627 uint64_t __attribute__((export_name("TS_Refund_clone"))) TS_Refund_clone(uint64_t orig) {
43628 LDKRefund orig_conv;
43629 orig_conv.inner = untag_ptr(orig);
43630 orig_conv.is_owned = ptr_is_owned(orig);
43631 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43632 orig_conv.is_owned = false;
43633 LDKRefund ret_var = Refund_clone(&orig_conv);
43634 uint64_t ret_ref = 0;
43635 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43636 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43640 uint64_t __attribute__((export_name("TS_Refund_description"))) TS_Refund_description(uint64_t this_arg) {
43641 LDKRefund this_arg_conv;
43642 this_arg_conv.inner = untag_ptr(this_arg);
43643 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43645 this_arg_conv.is_owned = false;
43646 LDKPrintableString ret_var = Refund_description(&this_arg_conv);
43647 uint64_t ret_ref = 0;
43648 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43649 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43653 uint64_t __attribute__((export_name("TS_Refund_absolute_expiry"))) TS_Refund_absolute_expiry(uint64_t this_arg) {
43654 LDKRefund this_arg_conv;
43655 this_arg_conv.inner = untag_ptr(this_arg);
43656 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43658 this_arg_conv.is_owned = false;
43659 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
43660 *ret_copy = Refund_absolute_expiry(&this_arg_conv);
43661 uint64_t ret_ref = tag_ptr(ret_copy, true);
43665 uint64_t __attribute__((export_name("TS_Refund_issuer"))) TS_Refund_issuer(uint64_t this_arg) {
43666 LDKRefund this_arg_conv;
43667 this_arg_conv.inner = untag_ptr(this_arg);
43668 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43670 this_arg_conv.is_owned = false;
43671 LDKPrintableString ret_var = Refund_issuer(&this_arg_conv);
43672 uint64_t ret_ref = 0;
43673 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43674 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43678 uint64_tArray __attribute__((export_name("TS_Refund_paths"))) TS_Refund_paths(uint64_t this_arg) {
43679 LDKRefund this_arg_conv;
43680 this_arg_conv.inner = untag_ptr(this_arg);
43681 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43683 this_arg_conv.is_owned = false;
43684 LDKCVec_BlindedPathZ ret_var = Refund_paths(&this_arg_conv);
43685 uint64_tArray ret_arr = NULL;
43686 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
43687 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
43688 for (size_t n = 0; n < ret_var.datalen; n++) {
43689 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
43690 uint64_t ret_conv_13_ref = 0;
43691 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
43692 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
43693 ret_arr_ptr[n] = ret_conv_13_ref;
43696 FREE(ret_var.data);
43700 int8_tArray __attribute__((export_name("TS_Refund_metadata"))) TS_Refund_metadata(uint64_t this_arg) {
43701 LDKRefund this_arg_conv;
43702 this_arg_conv.inner = untag_ptr(this_arg);
43703 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43704 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43705 this_arg_conv.is_owned = false;
43706 LDKu8slice ret_var = Refund_metadata(&this_arg_conv);
43707 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43708 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43712 int8_tArray __attribute__((export_name("TS_Refund_chain"))) TS_Refund_chain(uint64_t this_arg) {
43713 LDKRefund this_arg_conv;
43714 this_arg_conv.inner = untag_ptr(this_arg);
43715 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43716 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43717 this_arg_conv.is_owned = false;
43718 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43719 memcpy(ret_arr->elems, Refund_chain(&this_arg_conv).data, 32);
43723 int64_t __attribute__((export_name("TS_Refund_amount_msats"))) TS_Refund_amount_msats(uint64_t this_arg) {
43724 LDKRefund this_arg_conv;
43725 this_arg_conv.inner = untag_ptr(this_arg);
43726 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43728 this_arg_conv.is_owned = false;
43729 int64_t ret_conv = Refund_amount_msats(&this_arg_conv);
43733 uint64_t __attribute__((export_name("TS_Refund_features"))) TS_Refund_features(uint64_t this_arg) {
43734 LDKRefund this_arg_conv;
43735 this_arg_conv.inner = untag_ptr(this_arg);
43736 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43737 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43738 this_arg_conv.is_owned = false;
43739 LDKInvoiceRequestFeatures ret_var = Refund_features(&this_arg_conv);
43740 uint64_t ret_ref = 0;
43741 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43742 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43746 uint64_t __attribute__((export_name("TS_Refund_quantity"))) TS_Refund_quantity(uint64_t this_arg) {
43747 LDKRefund this_arg_conv;
43748 this_arg_conv.inner = untag_ptr(this_arg);
43749 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43750 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43751 this_arg_conv.is_owned = false;
43752 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
43753 *ret_copy = Refund_quantity(&this_arg_conv);
43754 uint64_t ret_ref = tag_ptr(ret_copy, true);
43758 int8_tArray __attribute__((export_name("TS_Refund_payer_id"))) TS_Refund_payer_id(uint64_t this_arg) {
43759 LDKRefund this_arg_conv;
43760 this_arg_conv.inner = untag_ptr(this_arg);
43761 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43763 this_arg_conv.is_owned = false;
43764 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
43765 memcpy(ret_arr->elems, Refund_payer_id(&this_arg_conv).compressed_form, 33);
43769 uint64_t __attribute__((export_name("TS_Refund_payer_note"))) TS_Refund_payer_note(uint64_t this_arg) {
43770 LDKRefund this_arg_conv;
43771 this_arg_conv.inner = untag_ptr(this_arg);
43772 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43774 this_arg_conv.is_owned = false;
43775 LDKPrintableString ret_var = Refund_payer_note(&this_arg_conv);
43776 uint64_t ret_ref = 0;
43777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43782 int8_tArray __attribute__((export_name("TS_Refund_write"))) TS_Refund_write(uint64_t obj) {
43783 LDKRefund obj_conv;
43784 obj_conv.inner = untag_ptr(obj);
43785 obj_conv.is_owned = ptr_is_owned(obj);
43786 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43787 obj_conv.is_owned = false;
43788 LDKCVec_u8Z ret_var = Refund_write(&obj_conv);
43789 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43790 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43791 CVec_u8Z_free(ret_var);
43795 uint32_t __attribute__((export_name("TS_UtxoLookupError_clone"))) TS_UtxoLookupError_clone(uint64_t orig) {
43796 LDKUtxoLookupError* orig_conv = (LDKUtxoLookupError*)untag_ptr(orig);
43797 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_clone(orig_conv));
43801 uint32_t __attribute__((export_name("TS_UtxoLookupError_unknown_chain"))) TS_UtxoLookupError_unknown_chain() {
43802 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_unknown_chain());
43806 uint32_t __attribute__((export_name("TS_UtxoLookupError_unknown_tx"))) TS_UtxoLookupError_unknown_tx() {
43807 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_unknown_tx());
43811 void __attribute__((export_name("TS_UtxoResult_free"))) TS_UtxoResult_free(uint64_t this_ptr) {
43812 if (!ptr_is_owned(this_ptr)) return;
43813 void* this_ptr_ptr = untag_ptr(this_ptr);
43814 CHECK_ACCESS(this_ptr_ptr);
43815 LDKUtxoResult this_ptr_conv = *(LDKUtxoResult*)(this_ptr_ptr);
43816 FREE(untag_ptr(this_ptr));
43817 UtxoResult_free(this_ptr_conv);
43820 static inline uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg) {
43821 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43822 *ret_copy = UtxoResult_clone(arg);
43823 uint64_t ret_ref = tag_ptr(ret_copy, true);
43826 int64_t __attribute__((export_name("TS_UtxoResult_clone_ptr"))) TS_UtxoResult_clone_ptr(uint64_t arg) {
43827 LDKUtxoResult* arg_conv = (LDKUtxoResult*)untag_ptr(arg);
43828 int64_t ret_conv = UtxoResult_clone_ptr(arg_conv);
43832 uint64_t __attribute__((export_name("TS_UtxoResult_clone"))) TS_UtxoResult_clone(uint64_t orig) {
43833 LDKUtxoResult* orig_conv = (LDKUtxoResult*)untag_ptr(orig);
43834 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43835 *ret_copy = UtxoResult_clone(orig_conv);
43836 uint64_t ret_ref = tag_ptr(ret_copy, true);
43840 uint64_t __attribute__((export_name("TS_UtxoResult_sync"))) TS_UtxoResult_sync(uint64_t a) {
43841 void* a_ptr = untag_ptr(a);
43842 CHECK_ACCESS(a_ptr);
43843 LDKCResult_TxOutUtxoLookupErrorZ a_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(a_ptr);
43844 a_conv = CResult_TxOutUtxoLookupErrorZ_clone((LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(a));
43845 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43846 *ret_copy = UtxoResult_sync(a_conv);
43847 uint64_t ret_ref = tag_ptr(ret_copy, true);
43851 uint64_t __attribute__((export_name("TS_UtxoResult_async"))) TS_UtxoResult_async(uint64_t a) {
43852 LDKUtxoFuture a_conv;
43853 a_conv.inner = untag_ptr(a);
43854 a_conv.is_owned = ptr_is_owned(a);
43855 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43856 a_conv = UtxoFuture_clone(&a_conv);
43857 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
43858 *ret_copy = UtxoResult_async(a_conv);
43859 uint64_t ret_ref = tag_ptr(ret_copy, true);
43863 void __attribute__((export_name("TS_UtxoLookup_free"))) TS_UtxoLookup_free(uint64_t this_ptr) {
43864 if (!ptr_is_owned(this_ptr)) return;
43865 void* this_ptr_ptr = untag_ptr(this_ptr);
43866 CHECK_ACCESS(this_ptr_ptr);
43867 LDKUtxoLookup this_ptr_conv = *(LDKUtxoLookup*)(this_ptr_ptr);
43868 FREE(untag_ptr(this_ptr));
43869 UtxoLookup_free(this_ptr_conv);
43872 void __attribute__((export_name("TS_UtxoFuture_free"))) TS_UtxoFuture_free(uint64_t this_obj) {
43873 LDKUtxoFuture this_obj_conv;
43874 this_obj_conv.inner = untag_ptr(this_obj);
43875 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43877 UtxoFuture_free(this_obj_conv);
43880 static inline uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg) {
43881 LDKUtxoFuture ret_var = UtxoFuture_clone(arg);
43882 uint64_t ret_ref = 0;
43883 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43884 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43887 int64_t __attribute__((export_name("TS_UtxoFuture_clone_ptr"))) TS_UtxoFuture_clone_ptr(uint64_t arg) {
43888 LDKUtxoFuture arg_conv;
43889 arg_conv.inner = untag_ptr(arg);
43890 arg_conv.is_owned = ptr_is_owned(arg);
43891 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43892 arg_conv.is_owned = false;
43893 int64_t ret_conv = UtxoFuture_clone_ptr(&arg_conv);
43897 uint64_t __attribute__((export_name("TS_UtxoFuture_clone"))) TS_UtxoFuture_clone(uint64_t orig) {
43898 LDKUtxoFuture orig_conv;
43899 orig_conv.inner = untag_ptr(orig);
43900 orig_conv.is_owned = ptr_is_owned(orig);
43901 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43902 orig_conv.is_owned = false;
43903 LDKUtxoFuture ret_var = UtxoFuture_clone(&orig_conv);
43904 uint64_t ret_ref = 0;
43905 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43906 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43910 uint64_t __attribute__((export_name("TS_UtxoFuture_new"))) TS_UtxoFuture_new() {
43911 LDKUtxoFuture ret_var = UtxoFuture_new();
43912 uint64_t ret_ref = 0;
43913 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43914 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43918 void __attribute__((export_name("TS_UtxoFuture_resolve_without_forwarding"))) TS_UtxoFuture_resolve_without_forwarding(uint64_t this_arg, uint64_t graph, uint64_t result) {
43919 LDKUtxoFuture this_arg_conv;
43920 this_arg_conv.inner = untag_ptr(this_arg);
43921 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43922 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43923 this_arg_conv.is_owned = false;
43924 LDKNetworkGraph graph_conv;
43925 graph_conv.inner = untag_ptr(graph);
43926 graph_conv.is_owned = ptr_is_owned(graph);
43927 CHECK_INNER_FIELD_ACCESS_OR_NULL(graph_conv);
43928 graph_conv.is_owned = false;
43929 void* result_ptr = untag_ptr(result);
43930 CHECK_ACCESS(result_ptr);
43931 LDKCResult_TxOutUtxoLookupErrorZ result_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(result_ptr);
43932 UtxoFuture_resolve_without_forwarding(&this_arg_conv, &graph_conv, result_conv);
43935 void __attribute__((export_name("TS_UtxoFuture_resolve"))) TS_UtxoFuture_resolve(uint64_t this_arg, uint64_t graph, uint64_t gossip, uint64_t result) {
43936 LDKUtxoFuture this_arg_conv;
43937 this_arg_conv.inner = untag_ptr(this_arg);
43938 this_arg_conv.is_owned = ptr_is_owned(this_arg);
43939 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43940 this_arg_conv.is_owned = false;
43941 LDKNetworkGraph graph_conv;
43942 graph_conv.inner = untag_ptr(graph);
43943 graph_conv.is_owned = ptr_is_owned(graph);
43944 CHECK_INNER_FIELD_ACCESS_OR_NULL(graph_conv);
43945 graph_conv.is_owned = false;
43946 LDKP2PGossipSync gossip_conv;
43947 gossip_conv.inner = untag_ptr(gossip);
43948 gossip_conv.is_owned = ptr_is_owned(gossip);
43949 CHECK_INNER_FIELD_ACCESS_OR_NULL(gossip_conv);
43950 gossip_conv.is_owned = false;
43951 void* result_ptr = untag_ptr(result);
43952 CHECK_ACCESS(result_ptr);
43953 LDKCResult_TxOutUtxoLookupErrorZ result_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(result_ptr);
43954 UtxoFuture_resolve(&this_arg_conv, &graph_conv, &gossip_conv, result_conv);
43957 void __attribute__((export_name("TS_NodeId_free"))) TS_NodeId_free(uint64_t this_obj) {
43958 LDKNodeId this_obj_conv;
43959 this_obj_conv.inner = untag_ptr(this_obj);
43960 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43962 NodeId_free(this_obj_conv);
43965 static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
43966 LDKNodeId ret_var = NodeId_clone(arg);
43967 uint64_t ret_ref = 0;
43968 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43969 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43972 int64_t __attribute__((export_name("TS_NodeId_clone_ptr"))) TS_NodeId_clone_ptr(uint64_t arg) {
43973 LDKNodeId arg_conv;
43974 arg_conv.inner = untag_ptr(arg);
43975 arg_conv.is_owned = ptr_is_owned(arg);
43976 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43977 arg_conv.is_owned = false;
43978 int64_t ret_conv = NodeId_clone_ptr(&arg_conv);
43982 uint64_t __attribute__((export_name("TS_NodeId_clone"))) TS_NodeId_clone(uint64_t orig) {
43983 LDKNodeId orig_conv;
43984 orig_conv.inner = untag_ptr(orig);
43985 orig_conv.is_owned = ptr_is_owned(orig);
43986 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43987 orig_conv.is_owned = false;
43988 LDKNodeId ret_var = NodeId_clone(&orig_conv);
43989 uint64_t ret_ref = 0;
43990 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43991 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43995 uint64_t __attribute__((export_name("TS_NodeId_from_pubkey"))) TS_NodeId_from_pubkey(int8_tArray pubkey) {
43996 LDKPublicKey pubkey_ref;
43997 CHECK(pubkey->arr_len == 33);
43998 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
43999 LDKNodeId ret_var = NodeId_from_pubkey(pubkey_ref);
44000 uint64_t ret_ref = 0;
44001 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44002 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44006 int8_tArray __attribute__((export_name("TS_NodeId_as_slice"))) TS_NodeId_as_slice(uint64_t this_arg) {
44007 LDKNodeId this_arg_conv;
44008 this_arg_conv.inner = untag_ptr(this_arg);
44009 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44011 this_arg_conv.is_owned = false;
44012 LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
44013 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44014 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44018 uint64_t __attribute__((export_name("TS_NodeId_as_pubkey"))) TS_NodeId_as_pubkey(uint64_t this_arg) {
44019 LDKNodeId this_arg_conv;
44020 this_arg_conv.inner = untag_ptr(this_arg);
44021 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44023 this_arg_conv.is_owned = false;
44024 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
44025 *ret_conv = NodeId_as_pubkey(&this_arg_conv);
44026 return tag_ptr(ret_conv, true);
44029 int64_t __attribute__((export_name("TS_NodeId_hash"))) TS_NodeId_hash(uint64_t o) {
44031 o_conv.inner = untag_ptr(o);
44032 o_conv.is_owned = ptr_is_owned(o);
44033 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44034 o_conv.is_owned = false;
44035 int64_t ret_conv = NodeId_hash(&o_conv);
44039 int8_tArray __attribute__((export_name("TS_NodeId_write"))) TS_NodeId_write(uint64_t obj) {
44040 LDKNodeId obj_conv;
44041 obj_conv.inner = untag_ptr(obj);
44042 obj_conv.is_owned = ptr_is_owned(obj);
44043 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44044 obj_conv.is_owned = false;
44045 LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
44046 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44047 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44048 CVec_u8Z_free(ret_var);
44052 uint64_t __attribute__((export_name("TS_NodeId_read"))) TS_NodeId_read(int8_tArray ser) {
44053 LDKu8slice ser_ref;
44054 ser_ref.datalen = ser->arr_len;
44055 ser_ref.data = ser->elems;
44056 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
44057 *ret_conv = NodeId_read(ser_ref);
44059 return tag_ptr(ret_conv, true);
44062 void __attribute__((export_name("TS_NetworkGraph_free"))) TS_NetworkGraph_free(uint64_t this_obj) {
44063 LDKNetworkGraph this_obj_conv;
44064 this_obj_conv.inner = untag_ptr(this_obj);
44065 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44067 NetworkGraph_free(this_obj_conv);
44070 void __attribute__((export_name("TS_ReadOnlyNetworkGraph_free"))) TS_ReadOnlyNetworkGraph_free(uint64_t this_obj) {
44071 LDKReadOnlyNetworkGraph this_obj_conv;
44072 this_obj_conv.inner = untag_ptr(this_obj);
44073 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44075 ReadOnlyNetworkGraph_free(this_obj_conv);
44078 void __attribute__((export_name("TS_NetworkUpdate_free"))) TS_NetworkUpdate_free(uint64_t this_ptr) {
44079 if (!ptr_is_owned(this_ptr)) return;
44080 void* this_ptr_ptr = untag_ptr(this_ptr);
44081 CHECK_ACCESS(this_ptr_ptr);
44082 LDKNetworkUpdate this_ptr_conv = *(LDKNetworkUpdate*)(this_ptr_ptr);
44083 FREE(untag_ptr(this_ptr));
44084 NetworkUpdate_free(this_ptr_conv);
44087 static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
44088 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44089 *ret_copy = NetworkUpdate_clone(arg);
44090 uint64_t ret_ref = tag_ptr(ret_copy, true);
44093 int64_t __attribute__((export_name("TS_NetworkUpdate_clone_ptr"))) TS_NetworkUpdate_clone_ptr(uint64_t arg) {
44094 LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)untag_ptr(arg);
44095 int64_t ret_conv = NetworkUpdate_clone_ptr(arg_conv);
44099 uint64_t __attribute__((export_name("TS_NetworkUpdate_clone"))) TS_NetworkUpdate_clone(uint64_t orig) {
44100 LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)untag_ptr(orig);
44101 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44102 *ret_copy = NetworkUpdate_clone(orig_conv);
44103 uint64_t ret_ref = tag_ptr(ret_copy, true);
44107 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_update_message"))) TS_NetworkUpdate_channel_update_message(uint64_t msg) {
44108 LDKChannelUpdate msg_conv;
44109 msg_conv.inner = untag_ptr(msg);
44110 msg_conv.is_owned = ptr_is_owned(msg);
44111 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
44112 msg_conv = ChannelUpdate_clone(&msg_conv);
44113 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44114 *ret_copy = NetworkUpdate_channel_update_message(msg_conv);
44115 uint64_t ret_ref = tag_ptr(ret_copy, true);
44119 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_failure"))) TS_NetworkUpdate_channel_failure(int64_t short_channel_id, jboolean is_permanent) {
44120 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44121 *ret_copy = NetworkUpdate_channel_failure(short_channel_id, is_permanent);
44122 uint64_t ret_ref = tag_ptr(ret_copy, true);
44126 uint64_t __attribute__((export_name("TS_NetworkUpdate_node_failure"))) TS_NetworkUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) {
44127 LDKPublicKey node_id_ref;
44128 CHECK(node_id->arr_len == 33);
44129 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
44130 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
44131 *ret_copy = NetworkUpdate_node_failure(node_id_ref, is_permanent);
44132 uint64_t ret_ref = tag_ptr(ret_copy, true);
44136 jboolean __attribute__((export_name("TS_NetworkUpdate_eq"))) TS_NetworkUpdate_eq(uint64_t a, uint64_t b) {
44137 LDKNetworkUpdate* a_conv = (LDKNetworkUpdate*)untag_ptr(a);
44138 LDKNetworkUpdate* b_conv = (LDKNetworkUpdate*)untag_ptr(b);
44139 jboolean ret_conv = NetworkUpdate_eq(a_conv, b_conv);
44143 int8_tArray __attribute__((export_name("TS_NetworkUpdate_write"))) TS_NetworkUpdate_write(uint64_t obj) {
44144 LDKNetworkUpdate* obj_conv = (LDKNetworkUpdate*)untag_ptr(obj);
44145 LDKCVec_u8Z ret_var = NetworkUpdate_write(obj_conv);
44146 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44147 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44148 CVec_u8Z_free(ret_var);
44152 uint64_t __attribute__((export_name("TS_NetworkUpdate_read"))) TS_NetworkUpdate_read(int8_tArray ser) {
44153 LDKu8slice ser_ref;
44154 ser_ref.datalen = ser->arr_len;
44155 ser_ref.data = ser->elems;
44156 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
44157 *ret_conv = NetworkUpdate_read(ser_ref);
44159 return tag_ptr(ret_conv, true);
44162 void __attribute__((export_name("TS_P2PGossipSync_free"))) TS_P2PGossipSync_free(uint64_t this_obj) {
44163 LDKP2PGossipSync this_obj_conv;
44164 this_obj_conv.inner = untag_ptr(this_obj);
44165 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44167 P2PGossipSync_free(this_obj_conv);
44170 uint64_t __attribute__((export_name("TS_P2PGossipSync_new"))) TS_P2PGossipSync_new(uint64_t network_graph, uint64_t utxo_lookup, uint64_t logger) {
44171 LDKNetworkGraph network_graph_conv;
44172 network_graph_conv.inner = untag_ptr(network_graph);
44173 network_graph_conv.is_owned = ptr_is_owned(network_graph);
44174 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
44175 network_graph_conv.is_owned = false;
44176 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
44177 CHECK_ACCESS(utxo_lookup_ptr);
44178 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
44179 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
44180 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
44181 // Manually implement clone for Java trait instances
44182 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
44183 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
44184 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
44187 void* logger_ptr = untag_ptr(logger);
44188 CHECK_ACCESS(logger_ptr);
44189 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
44190 if (logger_conv.free == LDKLogger_JCalls_free) {
44191 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
44192 LDKLogger_JCalls_cloned(&logger_conv);
44194 LDKP2PGossipSync ret_var = P2PGossipSync_new(&network_graph_conv, utxo_lookup_conv, logger_conv);
44195 uint64_t ret_ref = 0;
44196 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44197 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44201 void __attribute__((export_name("TS_P2PGossipSync_add_utxo_lookup"))) TS_P2PGossipSync_add_utxo_lookup(uint64_t this_arg, uint64_t utxo_lookup) {
44202 LDKP2PGossipSync this_arg_conv;
44203 this_arg_conv.inner = untag_ptr(this_arg);
44204 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44206 this_arg_conv.is_owned = false;
44207 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
44208 CHECK_ACCESS(utxo_lookup_ptr);
44209 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
44210 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
44211 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
44212 // Manually implement clone for Java trait instances
44213 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
44214 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
44215 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
44218 P2PGossipSync_add_utxo_lookup(&this_arg_conv, utxo_lookup_conv);
44221 void __attribute__((export_name("TS_NetworkGraph_handle_network_update"))) TS_NetworkGraph_handle_network_update(uint64_t this_arg, uint64_t network_update) {
44222 LDKNetworkGraph this_arg_conv;
44223 this_arg_conv.inner = untag_ptr(this_arg);
44224 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44226 this_arg_conv.is_owned = false;
44227 LDKNetworkUpdate* network_update_conv = (LDKNetworkUpdate*)untag_ptr(network_update);
44228 NetworkGraph_handle_network_update(&this_arg_conv, network_update_conv);
44231 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_RoutingMessageHandler"))) TS_P2PGossipSync_as_RoutingMessageHandler(uint64_t this_arg) {
44232 LDKP2PGossipSync this_arg_conv;
44233 this_arg_conv.inner = untag_ptr(this_arg);
44234 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44235 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44236 this_arg_conv.is_owned = false;
44237 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
44238 *ret_ret = P2PGossipSync_as_RoutingMessageHandler(&this_arg_conv);
44239 return tag_ptr(ret_ret, true);
44242 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_MessageSendEventsProvider"))) TS_P2PGossipSync_as_MessageSendEventsProvider(uint64_t this_arg) {
44243 LDKP2PGossipSync this_arg_conv;
44244 this_arg_conv.inner = untag_ptr(this_arg);
44245 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44246 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44247 this_arg_conv.is_owned = false;
44248 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
44249 *ret_ret = P2PGossipSync_as_MessageSendEventsProvider(&this_arg_conv);
44250 return tag_ptr(ret_ret, true);
44253 void __attribute__((export_name("TS_ChannelUpdateInfo_free"))) TS_ChannelUpdateInfo_free(uint64_t this_obj) {
44254 LDKChannelUpdateInfo this_obj_conv;
44255 this_obj_conv.inner = untag_ptr(this_obj);
44256 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44258 ChannelUpdateInfo_free(this_obj_conv);
44261 int32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update"))) TS_ChannelUpdateInfo_get_last_update(uint64_t this_ptr) {
44262 LDKChannelUpdateInfo this_ptr_conv;
44263 this_ptr_conv.inner = untag_ptr(this_ptr);
44264 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44266 this_ptr_conv.is_owned = false;
44267 int32_t ret_conv = ChannelUpdateInfo_get_last_update(&this_ptr_conv);
44271 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update"))) TS_ChannelUpdateInfo_set_last_update(uint64_t this_ptr, int32_t val) {
44272 LDKChannelUpdateInfo this_ptr_conv;
44273 this_ptr_conv.inner = untag_ptr(this_ptr);
44274 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44276 this_ptr_conv.is_owned = false;
44277 ChannelUpdateInfo_set_last_update(&this_ptr_conv, val);
44280 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_get_enabled"))) TS_ChannelUpdateInfo_get_enabled(uint64_t this_ptr) {
44281 LDKChannelUpdateInfo this_ptr_conv;
44282 this_ptr_conv.inner = untag_ptr(this_ptr);
44283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44285 this_ptr_conv.is_owned = false;
44286 jboolean ret_conv = ChannelUpdateInfo_get_enabled(&this_ptr_conv);
44290 void __attribute__((export_name("TS_ChannelUpdateInfo_set_enabled"))) TS_ChannelUpdateInfo_set_enabled(uint64_t this_ptr, jboolean val) {
44291 LDKChannelUpdateInfo this_ptr_conv;
44292 this_ptr_conv.inner = untag_ptr(this_ptr);
44293 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44295 this_ptr_conv.is_owned = false;
44296 ChannelUpdateInfo_set_enabled(&this_ptr_conv, val);
44299 int16_t __attribute__((export_name("TS_ChannelUpdateInfo_get_cltv_expiry_delta"))) TS_ChannelUpdateInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
44300 LDKChannelUpdateInfo this_ptr_conv;
44301 this_ptr_conv.inner = untag_ptr(this_ptr);
44302 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44304 this_ptr_conv.is_owned = false;
44305 int16_t ret_conv = ChannelUpdateInfo_get_cltv_expiry_delta(&this_ptr_conv);
44309 void __attribute__((export_name("TS_ChannelUpdateInfo_set_cltv_expiry_delta"))) TS_ChannelUpdateInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
44310 LDKChannelUpdateInfo this_ptr_conv;
44311 this_ptr_conv.inner = untag_ptr(this_ptr);
44312 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44313 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44314 this_ptr_conv.is_owned = false;
44315 ChannelUpdateInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
44318 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_minimum_msat"))) TS_ChannelUpdateInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
44319 LDKChannelUpdateInfo this_ptr_conv;
44320 this_ptr_conv.inner = untag_ptr(this_ptr);
44321 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44322 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44323 this_ptr_conv.is_owned = false;
44324 int64_t ret_conv = ChannelUpdateInfo_get_htlc_minimum_msat(&this_ptr_conv);
44328 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_minimum_msat"))) TS_ChannelUpdateInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
44329 LDKChannelUpdateInfo this_ptr_conv;
44330 this_ptr_conv.inner = untag_ptr(this_ptr);
44331 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44332 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44333 this_ptr_conv.is_owned = false;
44334 ChannelUpdateInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
44337 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_maximum_msat"))) TS_ChannelUpdateInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
44338 LDKChannelUpdateInfo this_ptr_conv;
44339 this_ptr_conv.inner = untag_ptr(this_ptr);
44340 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44341 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44342 this_ptr_conv.is_owned = false;
44343 int64_t ret_conv = ChannelUpdateInfo_get_htlc_maximum_msat(&this_ptr_conv);
44347 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_maximum_msat"))) TS_ChannelUpdateInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
44348 LDKChannelUpdateInfo this_ptr_conv;
44349 this_ptr_conv.inner = untag_ptr(this_ptr);
44350 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44352 this_ptr_conv.is_owned = false;
44353 ChannelUpdateInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
44356 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_fees"))) TS_ChannelUpdateInfo_get_fees(uint64_t this_ptr) {
44357 LDKChannelUpdateInfo this_ptr_conv;
44358 this_ptr_conv.inner = untag_ptr(this_ptr);
44359 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44361 this_ptr_conv.is_owned = false;
44362 LDKRoutingFees ret_var = ChannelUpdateInfo_get_fees(&this_ptr_conv);
44363 uint64_t ret_ref = 0;
44364 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44365 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44369 void __attribute__((export_name("TS_ChannelUpdateInfo_set_fees"))) TS_ChannelUpdateInfo_set_fees(uint64_t this_ptr, uint64_t val) {
44370 LDKChannelUpdateInfo this_ptr_conv;
44371 this_ptr_conv.inner = untag_ptr(this_ptr);
44372 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44374 this_ptr_conv.is_owned = false;
44375 LDKRoutingFees val_conv;
44376 val_conv.inner = untag_ptr(val);
44377 val_conv.is_owned = ptr_is_owned(val);
44378 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44379 val_conv = RoutingFees_clone(&val_conv);
44380 ChannelUpdateInfo_set_fees(&this_ptr_conv, val_conv);
44383 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update_message"))) TS_ChannelUpdateInfo_get_last_update_message(uint64_t this_ptr) {
44384 LDKChannelUpdateInfo this_ptr_conv;
44385 this_ptr_conv.inner = untag_ptr(this_ptr);
44386 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44388 this_ptr_conv.is_owned = false;
44389 LDKChannelUpdate ret_var = ChannelUpdateInfo_get_last_update_message(&this_ptr_conv);
44390 uint64_t ret_ref = 0;
44391 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44392 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44396 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update_message"))) TS_ChannelUpdateInfo_set_last_update_message(uint64_t this_ptr, uint64_t val) {
44397 LDKChannelUpdateInfo this_ptr_conv;
44398 this_ptr_conv.inner = untag_ptr(this_ptr);
44399 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44401 this_ptr_conv.is_owned = false;
44402 LDKChannelUpdate val_conv;
44403 val_conv.inner = untag_ptr(val);
44404 val_conv.is_owned = ptr_is_owned(val);
44405 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44406 val_conv = ChannelUpdate_clone(&val_conv);
44407 ChannelUpdateInfo_set_last_update_message(&this_ptr_conv, val_conv);
44410 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) {
44411 LDKRoutingFees fees_arg_conv;
44412 fees_arg_conv.inner = untag_ptr(fees_arg);
44413 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
44414 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
44415 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
44416 LDKChannelUpdate last_update_message_arg_conv;
44417 last_update_message_arg_conv.inner = untag_ptr(last_update_message_arg);
44418 last_update_message_arg_conv.is_owned = ptr_is_owned(last_update_message_arg);
44419 CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
44420 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
44421 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);
44422 uint64_t ret_ref = 0;
44423 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44424 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44428 static inline uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg) {
44429 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(arg);
44430 uint64_t ret_ref = 0;
44431 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44432 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44435 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone_ptr"))) TS_ChannelUpdateInfo_clone_ptr(uint64_t arg) {
44436 LDKChannelUpdateInfo arg_conv;
44437 arg_conv.inner = untag_ptr(arg);
44438 arg_conv.is_owned = ptr_is_owned(arg);
44439 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44440 arg_conv.is_owned = false;
44441 int64_t ret_conv = ChannelUpdateInfo_clone_ptr(&arg_conv);
44445 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone"))) TS_ChannelUpdateInfo_clone(uint64_t orig) {
44446 LDKChannelUpdateInfo orig_conv;
44447 orig_conv.inner = untag_ptr(orig);
44448 orig_conv.is_owned = ptr_is_owned(orig);
44449 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44450 orig_conv.is_owned = false;
44451 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(&orig_conv);
44452 uint64_t ret_ref = 0;
44453 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44454 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44458 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_eq"))) TS_ChannelUpdateInfo_eq(uint64_t a, uint64_t b) {
44459 LDKChannelUpdateInfo a_conv;
44460 a_conv.inner = untag_ptr(a);
44461 a_conv.is_owned = ptr_is_owned(a);
44462 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44463 a_conv.is_owned = false;
44464 LDKChannelUpdateInfo b_conv;
44465 b_conv.inner = untag_ptr(b);
44466 b_conv.is_owned = ptr_is_owned(b);
44467 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44468 b_conv.is_owned = false;
44469 jboolean ret_conv = ChannelUpdateInfo_eq(&a_conv, &b_conv);
44473 int8_tArray __attribute__((export_name("TS_ChannelUpdateInfo_write"))) TS_ChannelUpdateInfo_write(uint64_t obj) {
44474 LDKChannelUpdateInfo obj_conv;
44475 obj_conv.inner = untag_ptr(obj);
44476 obj_conv.is_owned = ptr_is_owned(obj);
44477 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44478 obj_conv.is_owned = false;
44479 LDKCVec_u8Z ret_var = ChannelUpdateInfo_write(&obj_conv);
44480 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44481 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44482 CVec_u8Z_free(ret_var);
44486 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_read"))) TS_ChannelUpdateInfo_read(int8_tArray ser) {
44487 LDKu8slice ser_ref;
44488 ser_ref.datalen = ser->arr_len;
44489 ser_ref.data = ser->elems;
44490 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
44491 *ret_conv = ChannelUpdateInfo_read(ser_ref);
44493 return tag_ptr(ret_conv, true);
44496 void __attribute__((export_name("TS_ChannelInfo_free"))) TS_ChannelInfo_free(uint64_t this_obj) {
44497 LDKChannelInfo this_obj_conv;
44498 this_obj_conv.inner = untag_ptr(this_obj);
44499 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44501 ChannelInfo_free(this_obj_conv);
44504 uint64_t __attribute__((export_name("TS_ChannelInfo_get_features"))) TS_ChannelInfo_get_features(uint64_t this_ptr) {
44505 LDKChannelInfo this_ptr_conv;
44506 this_ptr_conv.inner = untag_ptr(this_ptr);
44507 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44508 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44509 this_ptr_conv.is_owned = false;
44510 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
44511 uint64_t ret_ref = 0;
44512 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44513 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44517 void __attribute__((export_name("TS_ChannelInfo_set_features"))) TS_ChannelInfo_set_features(uint64_t this_ptr, uint64_t val) {
44518 LDKChannelInfo this_ptr_conv;
44519 this_ptr_conv.inner = untag_ptr(this_ptr);
44520 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44521 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44522 this_ptr_conv.is_owned = false;
44523 LDKChannelFeatures val_conv;
44524 val_conv.inner = untag_ptr(val);
44525 val_conv.is_owned = ptr_is_owned(val);
44526 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44527 val_conv = ChannelFeatures_clone(&val_conv);
44528 ChannelInfo_set_features(&this_ptr_conv, val_conv);
44531 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_one"))) TS_ChannelInfo_get_node_one(uint64_t this_ptr) {
44532 LDKChannelInfo this_ptr_conv;
44533 this_ptr_conv.inner = untag_ptr(this_ptr);
44534 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44535 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44536 this_ptr_conv.is_owned = false;
44537 LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
44538 uint64_t ret_ref = 0;
44539 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44540 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44544 void __attribute__((export_name("TS_ChannelInfo_set_node_one"))) TS_ChannelInfo_set_node_one(uint64_t this_ptr, uint64_t val) {
44545 LDKChannelInfo this_ptr_conv;
44546 this_ptr_conv.inner = untag_ptr(this_ptr);
44547 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44548 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44549 this_ptr_conv.is_owned = false;
44550 LDKNodeId val_conv;
44551 val_conv.inner = untag_ptr(val);
44552 val_conv.is_owned = ptr_is_owned(val);
44553 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44554 val_conv = NodeId_clone(&val_conv);
44555 ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
44558 uint64_t __attribute__((export_name("TS_ChannelInfo_get_one_to_two"))) TS_ChannelInfo_get_one_to_two(uint64_t this_ptr) {
44559 LDKChannelInfo this_ptr_conv;
44560 this_ptr_conv.inner = untag_ptr(this_ptr);
44561 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44562 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44563 this_ptr_conv.is_owned = false;
44564 LDKChannelUpdateInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
44565 uint64_t ret_ref = 0;
44566 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44567 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44571 void __attribute__((export_name("TS_ChannelInfo_set_one_to_two"))) TS_ChannelInfo_set_one_to_two(uint64_t this_ptr, uint64_t val) {
44572 LDKChannelInfo this_ptr_conv;
44573 this_ptr_conv.inner = untag_ptr(this_ptr);
44574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44576 this_ptr_conv.is_owned = false;
44577 LDKChannelUpdateInfo val_conv;
44578 val_conv.inner = untag_ptr(val);
44579 val_conv.is_owned = ptr_is_owned(val);
44580 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44581 val_conv = ChannelUpdateInfo_clone(&val_conv);
44582 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
44585 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_two"))) TS_ChannelInfo_get_node_two(uint64_t this_ptr) {
44586 LDKChannelInfo this_ptr_conv;
44587 this_ptr_conv.inner = untag_ptr(this_ptr);
44588 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44589 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44590 this_ptr_conv.is_owned = false;
44591 LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
44592 uint64_t ret_ref = 0;
44593 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44594 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44598 void __attribute__((export_name("TS_ChannelInfo_set_node_two"))) TS_ChannelInfo_set_node_two(uint64_t this_ptr, uint64_t val) {
44599 LDKChannelInfo this_ptr_conv;
44600 this_ptr_conv.inner = untag_ptr(this_ptr);
44601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44603 this_ptr_conv.is_owned = false;
44604 LDKNodeId val_conv;
44605 val_conv.inner = untag_ptr(val);
44606 val_conv.is_owned = ptr_is_owned(val);
44607 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44608 val_conv = NodeId_clone(&val_conv);
44609 ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
44612 uint64_t __attribute__((export_name("TS_ChannelInfo_get_two_to_one"))) TS_ChannelInfo_get_two_to_one(uint64_t this_ptr) {
44613 LDKChannelInfo this_ptr_conv;
44614 this_ptr_conv.inner = untag_ptr(this_ptr);
44615 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44616 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44617 this_ptr_conv.is_owned = false;
44618 LDKChannelUpdateInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
44619 uint64_t ret_ref = 0;
44620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44625 void __attribute__((export_name("TS_ChannelInfo_set_two_to_one"))) TS_ChannelInfo_set_two_to_one(uint64_t this_ptr, uint64_t val) {
44626 LDKChannelInfo this_ptr_conv;
44627 this_ptr_conv.inner = untag_ptr(this_ptr);
44628 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44630 this_ptr_conv.is_owned = false;
44631 LDKChannelUpdateInfo val_conv;
44632 val_conv.inner = untag_ptr(val);
44633 val_conv.is_owned = ptr_is_owned(val);
44634 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44635 val_conv = ChannelUpdateInfo_clone(&val_conv);
44636 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
44639 uint64_t __attribute__((export_name("TS_ChannelInfo_get_capacity_sats"))) TS_ChannelInfo_get_capacity_sats(uint64_t this_ptr) {
44640 LDKChannelInfo this_ptr_conv;
44641 this_ptr_conv.inner = untag_ptr(this_ptr);
44642 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44643 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44644 this_ptr_conv.is_owned = false;
44645 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
44646 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
44647 uint64_t ret_ref = tag_ptr(ret_copy, true);
44651 void __attribute__((export_name("TS_ChannelInfo_set_capacity_sats"))) TS_ChannelInfo_set_capacity_sats(uint64_t this_ptr, uint64_t val) {
44652 LDKChannelInfo this_ptr_conv;
44653 this_ptr_conv.inner = untag_ptr(this_ptr);
44654 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44656 this_ptr_conv.is_owned = false;
44657 void* val_ptr = untag_ptr(val);
44658 CHECK_ACCESS(val_ptr);
44659 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
44660 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
44661 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
44664 uint64_t __attribute__((export_name("TS_ChannelInfo_get_announcement_message"))) TS_ChannelInfo_get_announcement_message(uint64_t this_ptr) {
44665 LDKChannelInfo this_ptr_conv;
44666 this_ptr_conv.inner = untag_ptr(this_ptr);
44667 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44668 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44669 this_ptr_conv.is_owned = false;
44670 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
44671 uint64_t ret_ref = 0;
44672 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44673 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44677 void __attribute__((export_name("TS_ChannelInfo_set_announcement_message"))) TS_ChannelInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
44678 LDKChannelInfo this_ptr_conv;
44679 this_ptr_conv.inner = untag_ptr(this_ptr);
44680 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44681 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44682 this_ptr_conv.is_owned = false;
44683 LDKChannelAnnouncement val_conv;
44684 val_conv.inner = untag_ptr(val);
44685 val_conv.is_owned = ptr_is_owned(val);
44686 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44687 val_conv = ChannelAnnouncement_clone(&val_conv);
44688 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
44691 static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
44692 LDKChannelInfo ret_var = ChannelInfo_clone(arg);
44693 uint64_t ret_ref = 0;
44694 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44695 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44698 int64_t __attribute__((export_name("TS_ChannelInfo_clone_ptr"))) TS_ChannelInfo_clone_ptr(uint64_t arg) {
44699 LDKChannelInfo arg_conv;
44700 arg_conv.inner = untag_ptr(arg);
44701 arg_conv.is_owned = ptr_is_owned(arg);
44702 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44703 arg_conv.is_owned = false;
44704 int64_t ret_conv = ChannelInfo_clone_ptr(&arg_conv);
44708 uint64_t __attribute__((export_name("TS_ChannelInfo_clone"))) TS_ChannelInfo_clone(uint64_t orig) {
44709 LDKChannelInfo orig_conv;
44710 orig_conv.inner = untag_ptr(orig);
44711 orig_conv.is_owned = ptr_is_owned(orig);
44712 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44713 orig_conv.is_owned = false;
44714 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
44715 uint64_t ret_ref = 0;
44716 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44717 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44721 jboolean __attribute__((export_name("TS_ChannelInfo_eq"))) TS_ChannelInfo_eq(uint64_t a, uint64_t b) {
44722 LDKChannelInfo a_conv;
44723 a_conv.inner = untag_ptr(a);
44724 a_conv.is_owned = ptr_is_owned(a);
44725 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44726 a_conv.is_owned = false;
44727 LDKChannelInfo b_conv;
44728 b_conv.inner = untag_ptr(b);
44729 b_conv.is_owned = ptr_is_owned(b);
44730 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44731 b_conv.is_owned = false;
44732 jboolean ret_conv = ChannelInfo_eq(&a_conv, &b_conv);
44736 uint64_t __attribute__((export_name("TS_ChannelInfo_get_directional_info"))) TS_ChannelInfo_get_directional_info(uint64_t this_arg, int8_t channel_flags) {
44737 LDKChannelInfo this_arg_conv;
44738 this_arg_conv.inner = untag_ptr(this_arg);
44739 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44741 this_arg_conv.is_owned = false;
44742 LDKChannelUpdateInfo ret_var = ChannelInfo_get_directional_info(&this_arg_conv, channel_flags);
44743 uint64_t ret_ref = 0;
44744 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44745 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44749 int8_tArray __attribute__((export_name("TS_ChannelInfo_write"))) TS_ChannelInfo_write(uint64_t obj) {
44750 LDKChannelInfo obj_conv;
44751 obj_conv.inner = untag_ptr(obj);
44752 obj_conv.is_owned = ptr_is_owned(obj);
44753 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44754 obj_conv.is_owned = false;
44755 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
44756 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44757 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44758 CVec_u8Z_free(ret_var);
44762 uint64_t __attribute__((export_name("TS_ChannelInfo_read"))) TS_ChannelInfo_read(int8_tArray ser) {
44763 LDKu8slice ser_ref;
44764 ser_ref.datalen = ser->arr_len;
44765 ser_ref.data = ser->elems;
44766 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
44767 *ret_conv = ChannelInfo_read(ser_ref);
44769 return tag_ptr(ret_conv, true);
44772 void __attribute__((export_name("TS_DirectedChannelInfo_free"))) TS_DirectedChannelInfo_free(uint64_t this_obj) {
44773 LDKDirectedChannelInfo this_obj_conv;
44774 this_obj_conv.inner = untag_ptr(this_obj);
44775 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44776 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44777 DirectedChannelInfo_free(this_obj_conv);
44780 static inline uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg) {
44781 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(arg);
44782 uint64_t ret_ref = 0;
44783 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44784 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44787 int64_t __attribute__((export_name("TS_DirectedChannelInfo_clone_ptr"))) TS_DirectedChannelInfo_clone_ptr(uint64_t arg) {
44788 LDKDirectedChannelInfo arg_conv;
44789 arg_conv.inner = untag_ptr(arg);
44790 arg_conv.is_owned = ptr_is_owned(arg);
44791 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44792 arg_conv.is_owned = false;
44793 int64_t ret_conv = DirectedChannelInfo_clone_ptr(&arg_conv);
44797 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_clone"))) TS_DirectedChannelInfo_clone(uint64_t orig) {
44798 LDKDirectedChannelInfo orig_conv;
44799 orig_conv.inner = untag_ptr(orig);
44800 orig_conv.is_owned = ptr_is_owned(orig);
44801 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44802 orig_conv.is_owned = false;
44803 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(&orig_conv);
44804 uint64_t ret_ref = 0;
44805 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44806 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44810 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_channel"))) TS_DirectedChannelInfo_channel(uint64_t this_arg) {
44811 LDKDirectedChannelInfo this_arg_conv;
44812 this_arg_conv.inner = untag_ptr(this_arg);
44813 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44815 this_arg_conv.is_owned = false;
44816 LDKChannelInfo ret_var = DirectedChannelInfo_channel(&this_arg_conv);
44817 uint64_t ret_ref = 0;
44818 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44819 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44823 int64_t __attribute__((export_name("TS_DirectedChannelInfo_htlc_maximum_msat"))) TS_DirectedChannelInfo_htlc_maximum_msat(uint64_t this_arg) {
44824 LDKDirectedChannelInfo this_arg_conv;
44825 this_arg_conv.inner = untag_ptr(this_arg);
44826 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44828 this_arg_conv.is_owned = false;
44829 int64_t ret_conv = DirectedChannelInfo_htlc_maximum_msat(&this_arg_conv);
44833 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_effective_capacity"))) TS_DirectedChannelInfo_effective_capacity(uint64_t this_arg) {
44834 LDKDirectedChannelInfo this_arg_conv;
44835 this_arg_conv.inner = untag_ptr(this_arg);
44836 this_arg_conv.is_owned = ptr_is_owned(this_arg);
44837 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44838 this_arg_conv.is_owned = false;
44839 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44840 *ret_copy = DirectedChannelInfo_effective_capacity(&this_arg_conv);
44841 uint64_t ret_ref = tag_ptr(ret_copy, true);
44845 void __attribute__((export_name("TS_EffectiveCapacity_free"))) TS_EffectiveCapacity_free(uint64_t this_ptr) {
44846 if (!ptr_is_owned(this_ptr)) return;
44847 void* this_ptr_ptr = untag_ptr(this_ptr);
44848 CHECK_ACCESS(this_ptr_ptr);
44849 LDKEffectiveCapacity this_ptr_conv = *(LDKEffectiveCapacity*)(this_ptr_ptr);
44850 FREE(untag_ptr(this_ptr));
44851 EffectiveCapacity_free(this_ptr_conv);
44854 static inline uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg) {
44855 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44856 *ret_copy = EffectiveCapacity_clone(arg);
44857 uint64_t ret_ref = tag_ptr(ret_copy, true);
44860 int64_t __attribute__((export_name("TS_EffectiveCapacity_clone_ptr"))) TS_EffectiveCapacity_clone_ptr(uint64_t arg) {
44861 LDKEffectiveCapacity* arg_conv = (LDKEffectiveCapacity*)untag_ptr(arg);
44862 int64_t ret_conv = EffectiveCapacity_clone_ptr(arg_conv);
44866 uint64_t __attribute__((export_name("TS_EffectiveCapacity_clone"))) TS_EffectiveCapacity_clone(uint64_t orig) {
44867 LDKEffectiveCapacity* orig_conv = (LDKEffectiveCapacity*)untag_ptr(orig);
44868 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44869 *ret_copy = EffectiveCapacity_clone(orig_conv);
44870 uint64_t ret_ref = tag_ptr(ret_copy, true);
44874 uint64_t __attribute__((export_name("TS_EffectiveCapacity_exact_liquidity"))) TS_EffectiveCapacity_exact_liquidity(int64_t liquidity_msat) {
44875 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44876 *ret_copy = EffectiveCapacity_exact_liquidity(liquidity_msat);
44877 uint64_t ret_ref = tag_ptr(ret_copy, true);
44881 uint64_t __attribute__((export_name("TS_EffectiveCapacity_maximum_htlc"))) TS_EffectiveCapacity_maximum_htlc(int64_t amount_msat) {
44882 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44883 *ret_copy = EffectiveCapacity_maximum_htlc(amount_msat);
44884 uint64_t ret_ref = tag_ptr(ret_copy, true);
44888 uint64_t __attribute__((export_name("TS_EffectiveCapacity_total"))) TS_EffectiveCapacity_total(int64_t capacity_msat, int64_t htlc_maximum_msat) {
44889 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44890 *ret_copy = EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
44891 uint64_t ret_ref = tag_ptr(ret_copy, true);
44895 uint64_t __attribute__((export_name("TS_EffectiveCapacity_infinite"))) TS_EffectiveCapacity_infinite() {
44896 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44897 *ret_copy = EffectiveCapacity_infinite();
44898 uint64_t ret_ref = tag_ptr(ret_copy, true);
44902 uint64_t __attribute__((export_name("TS_EffectiveCapacity_unknown"))) TS_EffectiveCapacity_unknown() {
44903 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
44904 *ret_copy = EffectiveCapacity_unknown();
44905 uint64_t ret_ref = tag_ptr(ret_copy, true);
44909 int64_t __attribute__((export_name("TS_EffectiveCapacity_as_msat"))) TS_EffectiveCapacity_as_msat(uint64_t this_arg) {
44910 LDKEffectiveCapacity* this_arg_conv = (LDKEffectiveCapacity*)untag_ptr(this_arg);
44911 int64_t ret_conv = EffectiveCapacity_as_msat(this_arg_conv);
44915 void __attribute__((export_name("TS_RoutingFees_free"))) TS_RoutingFees_free(uint64_t this_obj) {
44916 LDKRoutingFees this_obj_conv;
44917 this_obj_conv.inner = untag_ptr(this_obj);
44918 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44920 RoutingFees_free(this_obj_conv);
44923 int32_t __attribute__((export_name("TS_RoutingFees_get_base_msat"))) TS_RoutingFees_get_base_msat(uint64_t this_ptr) {
44924 LDKRoutingFees this_ptr_conv;
44925 this_ptr_conv.inner = untag_ptr(this_ptr);
44926 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44928 this_ptr_conv.is_owned = false;
44929 int32_t ret_conv = RoutingFees_get_base_msat(&this_ptr_conv);
44933 void __attribute__((export_name("TS_RoutingFees_set_base_msat"))) TS_RoutingFees_set_base_msat(uint64_t this_ptr, int32_t val) {
44934 LDKRoutingFees this_ptr_conv;
44935 this_ptr_conv.inner = untag_ptr(this_ptr);
44936 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44938 this_ptr_conv.is_owned = false;
44939 RoutingFees_set_base_msat(&this_ptr_conv, val);
44942 int32_t __attribute__((export_name("TS_RoutingFees_get_proportional_millionths"))) TS_RoutingFees_get_proportional_millionths(uint64_t this_ptr) {
44943 LDKRoutingFees this_ptr_conv;
44944 this_ptr_conv.inner = untag_ptr(this_ptr);
44945 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44947 this_ptr_conv.is_owned = false;
44948 int32_t ret_conv = RoutingFees_get_proportional_millionths(&this_ptr_conv);
44952 void __attribute__((export_name("TS_RoutingFees_set_proportional_millionths"))) TS_RoutingFees_set_proportional_millionths(uint64_t this_ptr, int32_t val) {
44953 LDKRoutingFees this_ptr_conv;
44954 this_ptr_conv.inner = untag_ptr(this_ptr);
44955 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44957 this_ptr_conv.is_owned = false;
44958 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
44961 uint64_t __attribute__((export_name("TS_RoutingFees_new"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) {
44962 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
44963 uint64_t ret_ref = 0;
44964 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44965 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44969 jboolean __attribute__((export_name("TS_RoutingFees_eq"))) TS_RoutingFees_eq(uint64_t a, uint64_t b) {
44970 LDKRoutingFees a_conv;
44971 a_conv.inner = untag_ptr(a);
44972 a_conv.is_owned = ptr_is_owned(a);
44973 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44974 a_conv.is_owned = false;
44975 LDKRoutingFees b_conv;
44976 b_conv.inner = untag_ptr(b);
44977 b_conv.is_owned = ptr_is_owned(b);
44978 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44979 b_conv.is_owned = false;
44980 jboolean ret_conv = RoutingFees_eq(&a_conv, &b_conv);
44984 static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
44985 LDKRoutingFees ret_var = RoutingFees_clone(arg);
44986 uint64_t ret_ref = 0;
44987 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44988 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44991 int64_t __attribute__((export_name("TS_RoutingFees_clone_ptr"))) TS_RoutingFees_clone_ptr(uint64_t arg) {
44992 LDKRoutingFees arg_conv;
44993 arg_conv.inner = untag_ptr(arg);
44994 arg_conv.is_owned = ptr_is_owned(arg);
44995 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44996 arg_conv.is_owned = false;
44997 int64_t ret_conv = RoutingFees_clone_ptr(&arg_conv);
45001 uint64_t __attribute__((export_name("TS_RoutingFees_clone"))) TS_RoutingFees_clone(uint64_t orig) {
45002 LDKRoutingFees orig_conv;
45003 orig_conv.inner = untag_ptr(orig);
45004 orig_conv.is_owned = ptr_is_owned(orig);
45005 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45006 orig_conv.is_owned = false;
45007 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
45008 uint64_t ret_ref = 0;
45009 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45010 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45014 int64_t __attribute__((export_name("TS_RoutingFees_hash"))) TS_RoutingFees_hash(uint64_t o) {
45015 LDKRoutingFees o_conv;
45016 o_conv.inner = untag_ptr(o);
45017 o_conv.is_owned = ptr_is_owned(o);
45018 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
45019 o_conv.is_owned = false;
45020 int64_t ret_conv = RoutingFees_hash(&o_conv);
45024 int8_tArray __attribute__((export_name("TS_RoutingFees_write"))) TS_RoutingFees_write(uint64_t obj) {
45025 LDKRoutingFees obj_conv;
45026 obj_conv.inner = untag_ptr(obj);
45027 obj_conv.is_owned = ptr_is_owned(obj);
45028 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45029 obj_conv.is_owned = false;
45030 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
45031 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45032 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45033 CVec_u8Z_free(ret_var);
45037 uint64_t __attribute__((export_name("TS_RoutingFees_read"))) TS_RoutingFees_read(int8_tArray ser) {
45038 LDKu8slice ser_ref;
45039 ser_ref.datalen = ser->arr_len;
45040 ser_ref.data = ser->elems;
45041 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
45042 *ret_conv = RoutingFees_read(ser_ref);
45044 return tag_ptr(ret_conv, true);
45047 void __attribute__((export_name("TS_NodeAnnouncementInfo_free"))) TS_NodeAnnouncementInfo_free(uint64_t this_obj) {
45048 LDKNodeAnnouncementInfo this_obj_conv;
45049 this_obj_conv.inner = untag_ptr(this_obj);
45050 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45052 NodeAnnouncementInfo_free(this_obj_conv);
45055 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_features"))) TS_NodeAnnouncementInfo_get_features(uint64_t this_ptr) {
45056 LDKNodeAnnouncementInfo this_ptr_conv;
45057 this_ptr_conv.inner = untag_ptr(this_ptr);
45058 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45060 this_ptr_conv.is_owned = false;
45061 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
45062 uint64_t ret_ref = 0;
45063 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45064 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45068 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_features"))) TS_NodeAnnouncementInfo_set_features(uint64_t this_ptr, uint64_t val) {
45069 LDKNodeAnnouncementInfo this_ptr_conv;
45070 this_ptr_conv.inner = untag_ptr(this_ptr);
45071 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45072 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45073 this_ptr_conv.is_owned = false;
45074 LDKNodeFeatures val_conv;
45075 val_conv.inner = untag_ptr(val);
45076 val_conv.is_owned = ptr_is_owned(val);
45077 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45078 val_conv = NodeFeatures_clone(&val_conv);
45079 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
45082 int32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_last_update"))) TS_NodeAnnouncementInfo_get_last_update(uint64_t this_ptr) {
45083 LDKNodeAnnouncementInfo this_ptr_conv;
45084 this_ptr_conv.inner = untag_ptr(this_ptr);
45085 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45087 this_ptr_conv.is_owned = false;
45088 int32_t ret_conv = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
45092 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_last_update"))) TS_NodeAnnouncementInfo_set_last_update(uint64_t this_ptr, int32_t val) {
45093 LDKNodeAnnouncementInfo this_ptr_conv;
45094 this_ptr_conv.inner = untag_ptr(this_ptr);
45095 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45096 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45097 this_ptr_conv.is_owned = false;
45098 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
45101 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_get_rgb"))) TS_NodeAnnouncementInfo_get_rgb(uint64_t this_ptr) {
45102 LDKNodeAnnouncementInfo this_ptr_conv;
45103 this_ptr_conv.inner = untag_ptr(this_ptr);
45104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45106 this_ptr_conv.is_owned = false;
45107 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
45108 memcpy(ret_arr->elems, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
45112 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_rgb"))) TS_NodeAnnouncementInfo_set_rgb(uint64_t this_ptr, int8_tArray val) {
45113 LDKNodeAnnouncementInfo this_ptr_conv;
45114 this_ptr_conv.inner = untag_ptr(this_ptr);
45115 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45117 this_ptr_conv.is_owned = false;
45118 LDKThreeBytes val_ref;
45119 CHECK(val->arr_len == 3);
45120 memcpy(val_ref.data, val->elems, 3); FREE(val);
45121 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
45124 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_alias"))) TS_NodeAnnouncementInfo_get_alias(uint64_t this_ptr) {
45125 LDKNodeAnnouncementInfo this_ptr_conv;
45126 this_ptr_conv.inner = untag_ptr(this_ptr);
45127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45129 this_ptr_conv.is_owned = false;
45130 LDKNodeAlias ret_var = NodeAnnouncementInfo_get_alias(&this_ptr_conv);
45131 uint64_t ret_ref = 0;
45132 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45133 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45137 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_alias"))) TS_NodeAnnouncementInfo_set_alias(uint64_t this_ptr, uint64_t val) {
45138 LDKNodeAnnouncementInfo this_ptr_conv;
45139 this_ptr_conv.inner = untag_ptr(this_ptr);
45140 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45142 this_ptr_conv.is_owned = false;
45143 LDKNodeAlias val_conv;
45144 val_conv.inner = untag_ptr(val);
45145 val_conv.is_owned = ptr_is_owned(val);
45146 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45147 val_conv = NodeAlias_clone(&val_conv);
45148 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_conv);
45151 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_announcement_message"))) TS_NodeAnnouncementInfo_get_announcement_message(uint64_t this_ptr) {
45152 LDKNodeAnnouncementInfo this_ptr_conv;
45153 this_ptr_conv.inner = untag_ptr(this_ptr);
45154 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45156 this_ptr_conv.is_owned = false;
45157 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
45158 uint64_t ret_ref = 0;
45159 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45160 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45164 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_announcement_message"))) TS_NodeAnnouncementInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
45165 LDKNodeAnnouncementInfo this_ptr_conv;
45166 this_ptr_conv.inner = untag_ptr(this_ptr);
45167 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45169 this_ptr_conv.is_owned = false;
45170 LDKNodeAnnouncement val_conv;
45171 val_conv.inner = untag_ptr(val);
45172 val_conv.is_owned = ptr_is_owned(val);
45173 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45174 val_conv = NodeAnnouncement_clone(&val_conv);
45175 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
45178 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) {
45179 LDKNodeFeatures features_arg_conv;
45180 features_arg_conv.inner = untag_ptr(features_arg);
45181 features_arg_conv.is_owned = ptr_is_owned(features_arg);
45182 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
45183 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
45184 LDKThreeBytes rgb_arg_ref;
45185 CHECK(rgb_arg->arr_len == 3);
45186 memcpy(rgb_arg_ref.data, rgb_arg->elems, 3); FREE(rgb_arg);
45187 LDKNodeAlias alias_arg_conv;
45188 alias_arg_conv.inner = untag_ptr(alias_arg);
45189 alias_arg_conv.is_owned = ptr_is_owned(alias_arg);
45190 CHECK_INNER_FIELD_ACCESS_OR_NULL(alias_arg_conv);
45191 alias_arg_conv = NodeAlias_clone(&alias_arg_conv);
45192 LDKNodeAnnouncement announcement_message_arg_conv;
45193 announcement_message_arg_conv.inner = untag_ptr(announcement_message_arg);
45194 announcement_message_arg_conv.is_owned = ptr_is_owned(announcement_message_arg);
45195 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
45196 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
45197 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_conv, announcement_message_arg_conv);
45198 uint64_t ret_ref = 0;
45199 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45200 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45204 static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
45205 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
45206 uint64_t ret_ref = 0;
45207 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45208 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45211 int64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone_ptr"))) TS_NodeAnnouncementInfo_clone_ptr(uint64_t arg) {
45212 LDKNodeAnnouncementInfo arg_conv;
45213 arg_conv.inner = untag_ptr(arg);
45214 arg_conv.is_owned = ptr_is_owned(arg);
45215 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45216 arg_conv.is_owned = false;
45217 int64_t ret_conv = NodeAnnouncementInfo_clone_ptr(&arg_conv);
45221 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone"))) TS_NodeAnnouncementInfo_clone(uint64_t orig) {
45222 LDKNodeAnnouncementInfo orig_conv;
45223 orig_conv.inner = untag_ptr(orig);
45224 orig_conv.is_owned = ptr_is_owned(orig);
45225 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45226 orig_conv.is_owned = false;
45227 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
45228 uint64_t ret_ref = 0;
45229 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45230 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45234 jboolean __attribute__((export_name("TS_NodeAnnouncementInfo_eq"))) TS_NodeAnnouncementInfo_eq(uint64_t a, uint64_t b) {
45235 LDKNodeAnnouncementInfo a_conv;
45236 a_conv.inner = untag_ptr(a);
45237 a_conv.is_owned = ptr_is_owned(a);
45238 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45239 a_conv.is_owned = false;
45240 LDKNodeAnnouncementInfo b_conv;
45241 b_conv.inner = untag_ptr(b);
45242 b_conv.is_owned = ptr_is_owned(b);
45243 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45244 b_conv.is_owned = false;
45245 jboolean ret_conv = NodeAnnouncementInfo_eq(&a_conv, &b_conv);
45249 uint64_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_addresses"))) TS_NodeAnnouncementInfo_addresses(uint64_t this_arg) {
45250 LDKNodeAnnouncementInfo this_arg_conv;
45251 this_arg_conv.inner = untag_ptr(this_arg);
45252 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45254 this_arg_conv.is_owned = false;
45255 LDKCVec_NetAddressZ ret_var = NodeAnnouncementInfo_addresses(&this_arg_conv);
45256 uint64_tArray ret_arr = NULL;
45257 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
45258 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
45259 for (size_t m = 0; m < ret_var.datalen; m++) {
45260 LDKNetAddress *ret_conv_12_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
45261 *ret_conv_12_copy = ret_var.data[m];
45262 uint64_t ret_conv_12_ref = tag_ptr(ret_conv_12_copy, true);
45263 ret_arr_ptr[m] = ret_conv_12_ref;
45266 FREE(ret_var.data);
45270 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_write"))) TS_NodeAnnouncementInfo_write(uint64_t obj) {
45271 LDKNodeAnnouncementInfo obj_conv;
45272 obj_conv.inner = untag_ptr(obj);
45273 obj_conv.is_owned = ptr_is_owned(obj);
45274 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45275 obj_conv.is_owned = false;
45276 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
45277 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45278 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45279 CVec_u8Z_free(ret_var);
45283 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_read"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) {
45284 LDKu8slice ser_ref;
45285 ser_ref.datalen = ser->arr_len;
45286 ser_ref.data = ser->elems;
45287 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
45288 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
45290 return tag_ptr(ret_conv, true);
45293 void __attribute__((export_name("TS_NodeAlias_free"))) TS_NodeAlias_free(uint64_t this_obj) {
45294 LDKNodeAlias this_obj_conv;
45295 this_obj_conv.inner = untag_ptr(this_obj);
45296 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45297 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45298 NodeAlias_free(this_obj_conv);
45301 int8_tArray __attribute__((export_name("TS_NodeAlias_get_a"))) TS_NodeAlias_get_a(uint64_t this_ptr) {
45302 LDKNodeAlias this_ptr_conv;
45303 this_ptr_conv.inner = untag_ptr(this_ptr);
45304 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45306 this_ptr_conv.is_owned = false;
45307 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
45308 memcpy(ret_arr->elems, *NodeAlias_get_a(&this_ptr_conv), 32);
45312 void __attribute__((export_name("TS_NodeAlias_set_a"))) TS_NodeAlias_set_a(uint64_t this_ptr, int8_tArray val) {
45313 LDKNodeAlias this_ptr_conv;
45314 this_ptr_conv.inner = untag_ptr(this_ptr);
45315 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45317 this_ptr_conv.is_owned = false;
45318 LDKThirtyTwoBytes val_ref;
45319 CHECK(val->arr_len == 32);
45320 memcpy(val_ref.data, val->elems, 32); FREE(val);
45321 NodeAlias_set_a(&this_ptr_conv, val_ref);
45324 uint64_t __attribute__((export_name("TS_NodeAlias_new"))) TS_NodeAlias_new(int8_tArray a_arg) {
45325 LDKThirtyTwoBytes a_arg_ref;
45326 CHECK(a_arg->arr_len == 32);
45327 memcpy(a_arg_ref.data, a_arg->elems, 32); FREE(a_arg);
45328 LDKNodeAlias ret_var = NodeAlias_new(a_arg_ref);
45329 uint64_t ret_ref = 0;
45330 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45331 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45335 static inline uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg) {
45336 LDKNodeAlias ret_var = NodeAlias_clone(arg);
45337 uint64_t ret_ref = 0;
45338 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45339 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45342 int64_t __attribute__((export_name("TS_NodeAlias_clone_ptr"))) TS_NodeAlias_clone_ptr(uint64_t arg) {
45343 LDKNodeAlias arg_conv;
45344 arg_conv.inner = untag_ptr(arg);
45345 arg_conv.is_owned = ptr_is_owned(arg);
45346 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45347 arg_conv.is_owned = false;
45348 int64_t ret_conv = NodeAlias_clone_ptr(&arg_conv);
45352 uint64_t __attribute__((export_name("TS_NodeAlias_clone"))) TS_NodeAlias_clone(uint64_t orig) {
45353 LDKNodeAlias orig_conv;
45354 orig_conv.inner = untag_ptr(orig);
45355 orig_conv.is_owned = ptr_is_owned(orig);
45356 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45357 orig_conv.is_owned = false;
45358 LDKNodeAlias ret_var = NodeAlias_clone(&orig_conv);
45359 uint64_t ret_ref = 0;
45360 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45361 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45365 jboolean __attribute__((export_name("TS_NodeAlias_eq"))) TS_NodeAlias_eq(uint64_t a, uint64_t b) {
45366 LDKNodeAlias a_conv;
45367 a_conv.inner = untag_ptr(a);
45368 a_conv.is_owned = ptr_is_owned(a);
45369 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45370 a_conv.is_owned = false;
45371 LDKNodeAlias b_conv;
45372 b_conv.inner = untag_ptr(b);
45373 b_conv.is_owned = ptr_is_owned(b);
45374 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45375 b_conv.is_owned = false;
45376 jboolean ret_conv = NodeAlias_eq(&a_conv, &b_conv);
45380 int8_tArray __attribute__((export_name("TS_NodeAlias_write"))) TS_NodeAlias_write(uint64_t obj) {
45381 LDKNodeAlias obj_conv;
45382 obj_conv.inner = untag_ptr(obj);
45383 obj_conv.is_owned = ptr_is_owned(obj);
45384 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45385 obj_conv.is_owned = false;
45386 LDKCVec_u8Z ret_var = NodeAlias_write(&obj_conv);
45387 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45388 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45389 CVec_u8Z_free(ret_var);
45393 uint64_t __attribute__((export_name("TS_NodeAlias_read"))) TS_NodeAlias_read(int8_tArray ser) {
45394 LDKu8slice ser_ref;
45395 ser_ref.datalen = ser->arr_len;
45396 ser_ref.data = ser->elems;
45397 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
45398 *ret_conv = NodeAlias_read(ser_ref);
45400 return tag_ptr(ret_conv, true);
45403 void __attribute__((export_name("TS_NodeInfo_free"))) TS_NodeInfo_free(uint64_t this_obj) {
45404 LDKNodeInfo this_obj_conv;
45405 this_obj_conv.inner = untag_ptr(this_obj);
45406 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45408 NodeInfo_free(this_obj_conv);
45411 int64_tArray __attribute__((export_name("TS_NodeInfo_get_channels"))) TS_NodeInfo_get_channels(uint64_t this_ptr) {
45412 LDKNodeInfo this_ptr_conv;
45413 this_ptr_conv.inner = untag_ptr(this_ptr);
45414 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45415 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45416 this_ptr_conv.is_owned = false;
45417 LDKCVec_u64Z ret_var = NodeInfo_get_channels(&this_ptr_conv);
45418 int64_tArray ret_arr = NULL;
45419 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
45420 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
45421 for (size_t i = 0; i < ret_var.datalen; i++) {
45422 int64_t ret_conv_8_conv = ret_var.data[i];
45423 ret_arr_ptr[i] = ret_conv_8_conv;
45426 FREE(ret_var.data);
45430 void __attribute__((export_name("TS_NodeInfo_set_channels"))) TS_NodeInfo_set_channels(uint64_t this_ptr, int64_tArray val) {
45431 LDKNodeInfo this_ptr_conv;
45432 this_ptr_conv.inner = untag_ptr(this_ptr);
45433 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45435 this_ptr_conv.is_owned = false;
45436 LDKCVec_u64Z val_constr;
45437 val_constr.datalen = val->arr_len;
45438 if (val_constr.datalen > 0)
45439 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
45441 val_constr.data = NULL;
45442 int64_t* val_vals = val->elems;
45443 for (size_t i = 0; i < val_constr.datalen; i++) {
45444 int64_t val_conv_8 = val_vals[i];
45445 val_constr.data[i] = val_conv_8;
45448 NodeInfo_set_channels(&this_ptr_conv, val_constr);
45451 uint64_t __attribute__((export_name("TS_NodeInfo_get_announcement_info"))) TS_NodeInfo_get_announcement_info(uint64_t this_ptr) {
45452 LDKNodeInfo this_ptr_conv;
45453 this_ptr_conv.inner = untag_ptr(this_ptr);
45454 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45456 this_ptr_conv.is_owned = false;
45457 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
45458 uint64_t ret_ref = 0;
45459 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45460 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45464 void __attribute__((export_name("TS_NodeInfo_set_announcement_info"))) TS_NodeInfo_set_announcement_info(uint64_t this_ptr, uint64_t val) {
45465 LDKNodeInfo this_ptr_conv;
45466 this_ptr_conv.inner = untag_ptr(this_ptr);
45467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
45468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
45469 this_ptr_conv.is_owned = false;
45470 LDKNodeAnnouncementInfo val_conv;
45471 val_conv.inner = untag_ptr(val);
45472 val_conv.is_owned = ptr_is_owned(val);
45473 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
45474 val_conv = NodeAnnouncementInfo_clone(&val_conv);
45475 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
45478 uint64_t __attribute__((export_name("TS_NodeInfo_new"))) TS_NodeInfo_new(int64_tArray channels_arg, uint64_t announcement_info_arg) {
45479 LDKCVec_u64Z channels_arg_constr;
45480 channels_arg_constr.datalen = channels_arg->arr_len;
45481 if (channels_arg_constr.datalen > 0)
45482 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
45484 channels_arg_constr.data = NULL;
45485 int64_t* channels_arg_vals = channels_arg->elems;
45486 for (size_t i = 0; i < channels_arg_constr.datalen; i++) {
45487 int64_t channels_arg_conv_8 = channels_arg_vals[i];
45488 channels_arg_constr.data[i] = channels_arg_conv_8;
45490 FREE(channels_arg);
45491 LDKNodeAnnouncementInfo announcement_info_arg_conv;
45492 announcement_info_arg_conv.inner = untag_ptr(announcement_info_arg);
45493 announcement_info_arg_conv.is_owned = ptr_is_owned(announcement_info_arg);
45494 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
45495 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
45496 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, announcement_info_arg_conv);
45497 uint64_t ret_ref = 0;
45498 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45499 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45503 static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
45504 LDKNodeInfo ret_var = NodeInfo_clone(arg);
45505 uint64_t ret_ref = 0;
45506 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45507 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45510 int64_t __attribute__((export_name("TS_NodeInfo_clone_ptr"))) TS_NodeInfo_clone_ptr(uint64_t arg) {
45511 LDKNodeInfo arg_conv;
45512 arg_conv.inner = untag_ptr(arg);
45513 arg_conv.is_owned = ptr_is_owned(arg);
45514 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
45515 arg_conv.is_owned = false;
45516 int64_t ret_conv = NodeInfo_clone_ptr(&arg_conv);
45520 uint64_t __attribute__((export_name("TS_NodeInfo_clone"))) TS_NodeInfo_clone(uint64_t orig) {
45521 LDKNodeInfo orig_conv;
45522 orig_conv.inner = untag_ptr(orig);
45523 orig_conv.is_owned = ptr_is_owned(orig);
45524 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
45525 orig_conv.is_owned = false;
45526 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
45527 uint64_t ret_ref = 0;
45528 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45529 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45533 jboolean __attribute__((export_name("TS_NodeInfo_eq"))) TS_NodeInfo_eq(uint64_t a, uint64_t b) {
45534 LDKNodeInfo a_conv;
45535 a_conv.inner = untag_ptr(a);
45536 a_conv.is_owned = ptr_is_owned(a);
45537 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45538 a_conv.is_owned = false;
45539 LDKNodeInfo b_conv;
45540 b_conv.inner = untag_ptr(b);
45541 b_conv.is_owned = ptr_is_owned(b);
45542 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
45543 b_conv.is_owned = false;
45544 jboolean ret_conv = NodeInfo_eq(&a_conv, &b_conv);
45548 int8_tArray __attribute__((export_name("TS_NodeInfo_write"))) TS_NodeInfo_write(uint64_t obj) {
45549 LDKNodeInfo obj_conv;
45550 obj_conv.inner = untag_ptr(obj);
45551 obj_conv.is_owned = ptr_is_owned(obj);
45552 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45553 obj_conv.is_owned = false;
45554 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
45555 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45556 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45557 CVec_u8Z_free(ret_var);
45561 uint64_t __attribute__((export_name("TS_NodeInfo_read"))) TS_NodeInfo_read(int8_tArray ser) {
45562 LDKu8slice ser_ref;
45563 ser_ref.datalen = ser->arr_len;
45564 ser_ref.data = ser->elems;
45565 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
45566 *ret_conv = NodeInfo_read(ser_ref);
45568 return tag_ptr(ret_conv, true);
45571 int8_tArray __attribute__((export_name("TS_NetworkGraph_write"))) TS_NetworkGraph_write(uint64_t obj) {
45572 LDKNetworkGraph obj_conv;
45573 obj_conv.inner = untag_ptr(obj);
45574 obj_conv.is_owned = ptr_is_owned(obj);
45575 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45576 obj_conv.is_owned = false;
45577 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
45578 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45579 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45580 CVec_u8Z_free(ret_var);
45584 uint64_t __attribute__((export_name("TS_NetworkGraph_read"))) TS_NetworkGraph_read(int8_tArray ser, uint64_t arg) {
45585 LDKu8slice ser_ref;
45586 ser_ref.datalen = ser->arr_len;
45587 ser_ref.data = ser->elems;
45588 void* arg_ptr = untag_ptr(arg);
45589 CHECK_ACCESS(arg_ptr);
45590 LDKLogger arg_conv = *(LDKLogger*)(arg_ptr);
45591 if (arg_conv.free == LDKLogger_JCalls_free) {
45592 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45593 LDKLogger_JCalls_cloned(&arg_conv);
45595 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
45596 *ret_conv = NetworkGraph_read(ser_ref, arg_conv);
45598 return tag_ptr(ret_conv, true);
45601 uint64_t __attribute__((export_name("TS_NetworkGraph_new"))) TS_NetworkGraph_new(uint32_t network, uint64_t logger) {
45602 LDKNetwork network_conv = LDKNetwork_from_js(network);
45603 void* logger_ptr = untag_ptr(logger);
45604 CHECK_ACCESS(logger_ptr);
45605 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45606 if (logger_conv.free == LDKLogger_JCalls_free) {
45607 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45608 LDKLogger_JCalls_cloned(&logger_conv);
45610 LDKNetworkGraph ret_var = NetworkGraph_new(network_conv, logger_conv);
45611 uint64_t ret_ref = 0;
45612 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45613 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45617 uint64_t __attribute__((export_name("TS_NetworkGraph_read_only"))) TS_NetworkGraph_read_only(uint64_t this_arg) {
45618 LDKNetworkGraph this_arg_conv;
45619 this_arg_conv.inner = untag_ptr(this_arg);
45620 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45621 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45622 this_arg_conv.is_owned = false;
45623 LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
45624 uint64_t ret_ref = 0;
45625 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45626 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45630 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) {
45631 LDKNetworkGraph this_arg_conv;
45632 this_arg_conv.inner = untag_ptr(this_arg);
45633 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45635 this_arg_conv.is_owned = false;
45636 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
45637 *ret_copy = NetworkGraph_get_last_rapid_gossip_sync_timestamp(&this_arg_conv);
45638 uint64_t ret_ref = tag_ptr(ret_copy, true);
45642 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) {
45643 LDKNetworkGraph this_arg_conv;
45644 this_arg_conv.inner = untag_ptr(this_arg);
45645 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45647 this_arg_conv.is_owned = false;
45648 NetworkGraph_set_last_rapid_gossip_sync_timestamp(&this_arg_conv, last_rapid_gossip_sync_timestamp);
45651 uint64_t __attribute__((export_name("TS_NetworkGraph_update_node_from_announcement"))) TS_NetworkGraph_update_node_from_announcement(uint64_t this_arg, uint64_t msg) {
45652 LDKNetworkGraph this_arg_conv;
45653 this_arg_conv.inner = untag_ptr(this_arg);
45654 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45656 this_arg_conv.is_owned = false;
45657 LDKNodeAnnouncement msg_conv;
45658 msg_conv.inner = untag_ptr(msg);
45659 msg_conv.is_owned = ptr_is_owned(msg);
45660 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45661 msg_conv.is_owned = false;
45662 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45663 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
45664 return tag_ptr(ret_conv, true);
45667 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) {
45668 LDKNetworkGraph this_arg_conv;
45669 this_arg_conv.inner = untag_ptr(this_arg);
45670 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45672 this_arg_conv.is_owned = false;
45673 LDKUnsignedNodeAnnouncement msg_conv;
45674 msg_conv.inner = untag_ptr(msg);
45675 msg_conv.is_owned = ptr_is_owned(msg);
45676 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45677 msg_conv.is_owned = false;
45678 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45679 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
45680 return tag_ptr(ret_conv, true);
45683 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) {
45684 LDKNetworkGraph this_arg_conv;
45685 this_arg_conv.inner = untag_ptr(this_arg);
45686 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45687 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45688 this_arg_conv.is_owned = false;
45689 LDKChannelAnnouncement msg_conv;
45690 msg_conv.inner = untag_ptr(msg);
45691 msg_conv.is_owned = ptr_is_owned(msg);
45692 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45693 msg_conv.is_owned = false;
45694 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
45695 CHECK_ACCESS(utxo_lookup_ptr);
45696 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
45697 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
45698 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
45699 // Manually implement clone for Java trait instances
45700 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
45701 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45702 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
45705 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45706 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, utxo_lookup_conv);
45707 return tag_ptr(ret_conv, true);
45710 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) {
45711 LDKNetworkGraph this_arg_conv;
45712 this_arg_conv.inner = untag_ptr(this_arg);
45713 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45715 this_arg_conv.is_owned = false;
45716 LDKUnsignedChannelAnnouncement msg_conv;
45717 msg_conv.inner = untag_ptr(msg);
45718 msg_conv.is_owned = ptr_is_owned(msg);
45719 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45720 msg_conv.is_owned = false;
45721 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
45722 CHECK_ACCESS(utxo_lookup_ptr);
45723 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
45724 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
45725 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
45726 // Manually implement clone for Java trait instances
45727 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
45728 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45729 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
45732 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45733 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, utxo_lookup_conv);
45734 return tag_ptr(ret_conv, true);
45737 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) {
45738 LDKNetworkGraph this_arg_conv;
45739 this_arg_conv.inner = untag_ptr(this_arg);
45740 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45742 this_arg_conv.is_owned = false;
45743 LDKChannelFeatures features_conv;
45744 features_conv.inner = untag_ptr(features);
45745 features_conv.is_owned = ptr_is_owned(features);
45746 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
45747 features_conv = ChannelFeatures_clone(&features_conv);
45748 LDKPublicKey node_id_1_ref;
45749 CHECK(node_id_1->arr_len == 33);
45750 memcpy(node_id_1_ref.compressed_form, node_id_1->elems, 33); FREE(node_id_1);
45751 LDKPublicKey node_id_2_ref;
45752 CHECK(node_id_2->arr_len == 33);
45753 memcpy(node_id_2_ref.compressed_form, node_id_2->elems, 33); FREE(node_id_2);
45754 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45755 *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);
45756 return tag_ptr(ret_conv, true);
45759 void __attribute__((export_name("TS_NetworkGraph_channel_failed_permanent"))) TS_NetworkGraph_channel_failed_permanent(uint64_t this_arg, int64_t short_channel_id) {
45760 LDKNetworkGraph this_arg_conv;
45761 this_arg_conv.inner = untag_ptr(this_arg);
45762 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45764 this_arg_conv.is_owned = false;
45765 NetworkGraph_channel_failed_permanent(&this_arg_conv, short_channel_id);
45768 void __attribute__((export_name("TS_NetworkGraph_node_failed_permanent"))) TS_NetworkGraph_node_failed_permanent(uint64_t this_arg, int8_tArray node_id) {
45769 LDKNetworkGraph this_arg_conv;
45770 this_arg_conv.inner = untag_ptr(this_arg);
45771 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45772 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45773 this_arg_conv.is_owned = false;
45774 LDKPublicKey node_id_ref;
45775 CHECK(node_id->arr_len == 33);
45776 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
45777 NetworkGraph_node_failed_permanent(&this_arg_conv, node_id_ref);
45780 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) {
45781 LDKNetworkGraph this_arg_conv;
45782 this_arg_conv.inner = untag_ptr(this_arg);
45783 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45784 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45785 this_arg_conv.is_owned = false;
45786 NetworkGraph_remove_stale_channels_and_tracking_with_time(&this_arg_conv, current_time_unix);
45789 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel"))) TS_NetworkGraph_update_channel(uint64_t this_arg, uint64_t msg) {
45790 LDKNetworkGraph this_arg_conv;
45791 this_arg_conv.inner = untag_ptr(this_arg);
45792 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45793 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45794 this_arg_conv.is_owned = false;
45795 LDKChannelUpdate msg_conv;
45796 msg_conv.inner = untag_ptr(msg);
45797 msg_conv.is_owned = ptr_is_owned(msg);
45798 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45799 msg_conv.is_owned = false;
45800 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45801 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
45802 return tag_ptr(ret_conv, true);
45805 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_unsigned"))) TS_NetworkGraph_update_channel_unsigned(uint64_t this_arg, uint64_t msg) {
45806 LDKNetworkGraph this_arg_conv;
45807 this_arg_conv.inner = untag_ptr(this_arg);
45808 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45810 this_arg_conv.is_owned = false;
45811 LDKUnsignedChannelUpdate msg_conv;
45812 msg_conv.inner = untag_ptr(msg);
45813 msg_conv.is_owned = ptr_is_owned(msg);
45814 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
45815 msg_conv.is_owned = false;
45816 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
45817 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
45818 return tag_ptr(ret_conv, true);
45821 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_channel"))) TS_ReadOnlyNetworkGraph_channel(uint64_t this_arg, int64_t short_channel_id) {
45822 LDKReadOnlyNetworkGraph this_arg_conv;
45823 this_arg_conv.inner = untag_ptr(this_arg);
45824 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45826 this_arg_conv.is_owned = false;
45827 LDKChannelInfo ret_var = ReadOnlyNetworkGraph_channel(&this_arg_conv, short_channel_id);
45828 uint64_t ret_ref = 0;
45829 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45830 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45834 int64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_channels"))) TS_ReadOnlyNetworkGraph_list_channels(uint64_t this_arg) {
45835 LDKReadOnlyNetworkGraph this_arg_conv;
45836 this_arg_conv.inner = untag_ptr(this_arg);
45837 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45839 this_arg_conv.is_owned = false;
45840 LDKCVec_u64Z ret_var = ReadOnlyNetworkGraph_list_channels(&this_arg_conv);
45841 int64_tArray ret_arr = NULL;
45842 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
45843 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
45844 for (size_t i = 0; i < ret_var.datalen; i++) {
45845 int64_t ret_conv_8_conv = ret_var.data[i];
45846 ret_arr_ptr[i] = ret_conv_8_conv;
45849 FREE(ret_var.data);
45853 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_node"))) TS_ReadOnlyNetworkGraph_node(uint64_t this_arg, uint64_t node_id) {
45854 LDKReadOnlyNetworkGraph this_arg_conv;
45855 this_arg_conv.inner = untag_ptr(this_arg);
45856 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45858 this_arg_conv.is_owned = false;
45859 LDKNodeId node_id_conv;
45860 node_id_conv.inner = untag_ptr(node_id);
45861 node_id_conv.is_owned = ptr_is_owned(node_id);
45862 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
45863 node_id_conv.is_owned = false;
45864 LDKNodeInfo ret_var = ReadOnlyNetworkGraph_node(&this_arg_conv, &node_id_conv);
45865 uint64_t ret_ref = 0;
45866 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45867 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45871 uint64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_nodes"))) TS_ReadOnlyNetworkGraph_list_nodes(uint64_t this_arg) {
45872 LDKReadOnlyNetworkGraph this_arg_conv;
45873 this_arg_conv.inner = untag_ptr(this_arg);
45874 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45876 this_arg_conv.is_owned = false;
45877 LDKCVec_NodeIdZ ret_var = ReadOnlyNetworkGraph_list_nodes(&this_arg_conv);
45878 uint64_tArray ret_arr = NULL;
45879 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
45880 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
45881 for (size_t i = 0; i < ret_var.datalen; i++) {
45882 LDKNodeId ret_conv_8_var = ret_var.data[i];
45883 uint64_t ret_conv_8_ref = 0;
45884 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_8_var);
45885 ret_conv_8_ref = tag_ptr(ret_conv_8_var.inner, ret_conv_8_var.is_owned);
45886 ret_arr_ptr[i] = ret_conv_8_ref;
45889 FREE(ret_var.data);
45893 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_get_addresses"))) TS_ReadOnlyNetworkGraph_get_addresses(uint64_t this_arg, int8_tArray pubkey) {
45894 LDKReadOnlyNetworkGraph this_arg_conv;
45895 this_arg_conv.inner = untag_ptr(this_arg);
45896 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45898 this_arg_conv.is_owned = false;
45899 LDKPublicKey pubkey_ref;
45900 CHECK(pubkey->arr_len == 33);
45901 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
45902 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
45903 *ret_copy = ReadOnlyNetworkGraph_get_addresses(&this_arg_conv, pubkey_ref);
45904 uint64_t ret_ref = tag_ptr(ret_copy, true);
45908 void __attribute__((export_name("TS_DefaultRouter_free"))) TS_DefaultRouter_free(uint64_t this_obj) {
45909 LDKDefaultRouter this_obj_conv;
45910 this_obj_conv.inner = untag_ptr(this_obj);
45911 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45912 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45913 DefaultRouter_free(this_obj_conv);
45916 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) {
45917 LDKNetworkGraph network_graph_conv;
45918 network_graph_conv.inner = untag_ptr(network_graph);
45919 network_graph_conv.is_owned = ptr_is_owned(network_graph);
45920 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
45921 network_graph_conv.is_owned = false;
45922 void* logger_ptr = untag_ptr(logger);
45923 CHECK_ACCESS(logger_ptr);
45924 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45925 if (logger_conv.free == LDKLogger_JCalls_free) {
45926 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45927 LDKLogger_JCalls_cloned(&logger_conv);
45929 LDKThirtyTwoBytes random_seed_bytes_ref;
45930 CHECK(random_seed_bytes->arr_len == 32);
45931 memcpy(random_seed_bytes_ref.data, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
45932 void* scorer_ptr = untag_ptr(scorer);
45933 CHECK_ACCESS(scorer_ptr);
45934 LDKLockableScore scorer_conv = *(LDKLockableScore*)(scorer_ptr);
45935 if (scorer_conv.free == LDKLockableScore_JCalls_free) {
45936 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45937 LDKLockableScore_JCalls_cloned(&scorer_conv);
45939 LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref, scorer_conv);
45940 uint64_t ret_ref = 0;
45941 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45942 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45946 uint64_t __attribute__((export_name("TS_DefaultRouter_as_Router"))) TS_DefaultRouter_as_Router(uint64_t this_arg) {
45947 LDKDefaultRouter this_arg_conv;
45948 this_arg_conv.inner = untag_ptr(this_arg);
45949 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45951 this_arg_conv.is_owned = false;
45952 LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
45953 *ret_ret = DefaultRouter_as_Router(&this_arg_conv);
45954 return tag_ptr(ret_ret, true);
45957 void __attribute__((export_name("TS_Router_free"))) TS_Router_free(uint64_t this_ptr) {
45958 if (!ptr_is_owned(this_ptr)) return;
45959 void* this_ptr_ptr = untag_ptr(this_ptr);
45960 CHECK_ACCESS(this_ptr_ptr);
45961 LDKRouter this_ptr_conv = *(LDKRouter*)(this_ptr_ptr);
45962 FREE(untag_ptr(this_ptr));
45963 Router_free(this_ptr_conv);
45966 void __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_free"))) TS_ScorerAccountingForInFlightHtlcs_free(uint64_t this_obj) {
45967 LDKScorerAccountingForInFlightHtlcs this_obj_conv;
45968 this_obj_conv.inner = untag_ptr(this_obj);
45969 this_obj_conv.is_owned = ptr_is_owned(this_obj);
45970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45971 ScorerAccountingForInFlightHtlcs_free(this_obj_conv);
45974 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_new"))) TS_ScorerAccountingForInFlightHtlcs_new(uint64_t scorer, uint64_t inflight_htlcs) {
45975 void* scorer_ptr = untag_ptr(scorer);
45976 CHECK_ACCESS(scorer_ptr);
45977 LDKScore scorer_conv = *(LDKScore*)(scorer_ptr);
45978 if (scorer_conv.free == LDKScore_JCalls_free) {
45979 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45980 LDKScore_JCalls_cloned(&scorer_conv);
45982 LDKInFlightHtlcs inflight_htlcs_conv;
45983 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
45984 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
45985 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
45986 inflight_htlcs_conv.is_owned = false;
45987 LDKScorerAccountingForInFlightHtlcs ret_var = ScorerAccountingForInFlightHtlcs_new(scorer_conv, &inflight_htlcs_conv);
45988 uint64_t ret_ref = 0;
45989 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45990 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
45994 int8_tArray __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_write"))) TS_ScorerAccountingForInFlightHtlcs_write(uint64_t obj) {
45995 LDKScorerAccountingForInFlightHtlcs obj_conv;
45996 obj_conv.inner = untag_ptr(obj);
45997 obj_conv.is_owned = ptr_is_owned(obj);
45998 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45999 obj_conv.is_owned = false;
46000 LDKCVec_u8Z ret_var = ScorerAccountingForInFlightHtlcs_write(&obj_conv);
46001 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46002 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46003 CVec_u8Z_free(ret_var);
46007 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_as_Score"))) TS_ScorerAccountingForInFlightHtlcs_as_Score(uint64_t this_arg) {
46008 LDKScorerAccountingForInFlightHtlcs this_arg_conv;
46009 this_arg_conv.inner = untag_ptr(this_arg);
46010 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46012 this_arg_conv.is_owned = false;
46013 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
46014 *ret_ret = ScorerAccountingForInFlightHtlcs_as_Score(&this_arg_conv);
46015 return tag_ptr(ret_ret, true);
46018 void __attribute__((export_name("TS_InFlightHtlcs_free"))) TS_InFlightHtlcs_free(uint64_t this_obj) {
46019 LDKInFlightHtlcs this_obj_conv;
46020 this_obj_conv.inner = untag_ptr(this_obj);
46021 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46023 InFlightHtlcs_free(this_obj_conv);
46026 static inline uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg) {
46027 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(arg);
46028 uint64_t ret_ref = 0;
46029 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46030 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46033 int64_t __attribute__((export_name("TS_InFlightHtlcs_clone_ptr"))) TS_InFlightHtlcs_clone_ptr(uint64_t arg) {
46034 LDKInFlightHtlcs arg_conv;
46035 arg_conv.inner = untag_ptr(arg);
46036 arg_conv.is_owned = ptr_is_owned(arg);
46037 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46038 arg_conv.is_owned = false;
46039 int64_t ret_conv = InFlightHtlcs_clone_ptr(&arg_conv);
46043 uint64_t __attribute__((export_name("TS_InFlightHtlcs_clone"))) TS_InFlightHtlcs_clone(uint64_t orig) {
46044 LDKInFlightHtlcs orig_conv;
46045 orig_conv.inner = untag_ptr(orig);
46046 orig_conv.is_owned = ptr_is_owned(orig);
46047 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46048 orig_conv.is_owned = false;
46049 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(&orig_conv);
46050 uint64_t ret_ref = 0;
46051 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46052 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46056 uint64_t __attribute__((export_name("TS_InFlightHtlcs_new"))) TS_InFlightHtlcs_new() {
46057 LDKInFlightHtlcs ret_var = InFlightHtlcs_new();
46058 uint64_t ret_ref = 0;
46059 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46060 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46064 void __attribute__((export_name("TS_InFlightHtlcs_process_path"))) TS_InFlightHtlcs_process_path(uint64_t this_arg, uint64_t path, int8_tArray payer_node_id) {
46065 LDKInFlightHtlcs this_arg_conv;
46066 this_arg_conv.inner = untag_ptr(this_arg);
46067 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46068 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46069 this_arg_conv.is_owned = false;
46071 path_conv.inner = untag_ptr(path);
46072 path_conv.is_owned = ptr_is_owned(path);
46073 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
46074 path_conv.is_owned = false;
46075 LDKPublicKey payer_node_id_ref;
46076 CHECK(payer_node_id->arr_len == 33);
46077 memcpy(payer_node_id_ref.compressed_form, payer_node_id->elems, 33); FREE(payer_node_id);
46078 InFlightHtlcs_process_path(&this_arg_conv, &path_conv, payer_node_id_ref);
46081 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) {
46082 LDKInFlightHtlcs this_arg_conv;
46083 this_arg_conv.inner = untag_ptr(this_arg);
46084 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46085 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46086 this_arg_conv.is_owned = false;
46087 LDKNodeId source_conv;
46088 source_conv.inner = untag_ptr(source);
46089 source_conv.is_owned = ptr_is_owned(source);
46090 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
46091 source_conv.is_owned = false;
46092 LDKNodeId target_conv;
46093 target_conv.inner = untag_ptr(target);
46094 target_conv.is_owned = ptr_is_owned(target);
46095 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
46096 target_conv.is_owned = false;
46097 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
46098 *ret_copy = InFlightHtlcs_used_liquidity_msat(&this_arg_conv, &source_conv, &target_conv, channel_scid);
46099 uint64_t ret_ref = tag_ptr(ret_copy, true);
46103 int8_tArray __attribute__((export_name("TS_InFlightHtlcs_write"))) TS_InFlightHtlcs_write(uint64_t obj) {
46104 LDKInFlightHtlcs obj_conv;
46105 obj_conv.inner = untag_ptr(obj);
46106 obj_conv.is_owned = ptr_is_owned(obj);
46107 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46108 obj_conv.is_owned = false;
46109 LDKCVec_u8Z ret_var = InFlightHtlcs_write(&obj_conv);
46110 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46111 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46112 CVec_u8Z_free(ret_var);
46116 uint64_t __attribute__((export_name("TS_InFlightHtlcs_read"))) TS_InFlightHtlcs_read(int8_tArray ser) {
46117 LDKu8slice ser_ref;
46118 ser_ref.datalen = ser->arr_len;
46119 ser_ref.data = ser->elems;
46120 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
46121 *ret_conv = InFlightHtlcs_read(ser_ref);
46123 return tag_ptr(ret_conv, true);
46126 void __attribute__((export_name("TS_RouteHop_free"))) TS_RouteHop_free(uint64_t this_obj) {
46127 LDKRouteHop this_obj_conv;
46128 this_obj_conv.inner = untag_ptr(this_obj);
46129 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46131 RouteHop_free(this_obj_conv);
46134 int8_tArray __attribute__((export_name("TS_RouteHop_get_pubkey"))) TS_RouteHop_get_pubkey(uint64_t this_ptr) {
46135 LDKRouteHop this_ptr_conv;
46136 this_ptr_conv.inner = untag_ptr(this_ptr);
46137 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46139 this_ptr_conv.is_owned = false;
46140 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46141 memcpy(ret_arr->elems, RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
46145 void __attribute__((export_name("TS_RouteHop_set_pubkey"))) TS_RouteHop_set_pubkey(uint64_t this_ptr, int8_tArray val) {
46146 LDKRouteHop this_ptr_conv;
46147 this_ptr_conv.inner = untag_ptr(this_ptr);
46148 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46149 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46150 this_ptr_conv.is_owned = false;
46151 LDKPublicKey val_ref;
46152 CHECK(val->arr_len == 33);
46153 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46154 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
46157 uint64_t __attribute__((export_name("TS_RouteHop_get_node_features"))) TS_RouteHop_get_node_features(uint64_t this_ptr) {
46158 LDKRouteHop this_ptr_conv;
46159 this_ptr_conv.inner = untag_ptr(this_ptr);
46160 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46162 this_ptr_conv.is_owned = false;
46163 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
46164 uint64_t ret_ref = 0;
46165 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46166 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46170 void __attribute__((export_name("TS_RouteHop_set_node_features"))) TS_RouteHop_set_node_features(uint64_t this_ptr, uint64_t val) {
46171 LDKRouteHop this_ptr_conv;
46172 this_ptr_conv.inner = untag_ptr(this_ptr);
46173 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46175 this_ptr_conv.is_owned = false;
46176 LDKNodeFeatures val_conv;
46177 val_conv.inner = untag_ptr(val);
46178 val_conv.is_owned = ptr_is_owned(val);
46179 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46180 val_conv = NodeFeatures_clone(&val_conv);
46181 RouteHop_set_node_features(&this_ptr_conv, val_conv);
46184 int64_t __attribute__((export_name("TS_RouteHop_get_short_channel_id"))) TS_RouteHop_get_short_channel_id(uint64_t this_ptr) {
46185 LDKRouteHop this_ptr_conv;
46186 this_ptr_conv.inner = untag_ptr(this_ptr);
46187 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46189 this_ptr_conv.is_owned = false;
46190 int64_t ret_conv = RouteHop_get_short_channel_id(&this_ptr_conv);
46194 void __attribute__((export_name("TS_RouteHop_set_short_channel_id"))) TS_RouteHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
46195 LDKRouteHop this_ptr_conv;
46196 this_ptr_conv.inner = untag_ptr(this_ptr);
46197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46199 this_ptr_conv.is_owned = false;
46200 RouteHop_set_short_channel_id(&this_ptr_conv, val);
46203 uint64_t __attribute__((export_name("TS_RouteHop_get_channel_features"))) TS_RouteHop_get_channel_features(uint64_t this_ptr) {
46204 LDKRouteHop this_ptr_conv;
46205 this_ptr_conv.inner = untag_ptr(this_ptr);
46206 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46208 this_ptr_conv.is_owned = false;
46209 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
46210 uint64_t ret_ref = 0;
46211 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46212 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46216 void __attribute__((export_name("TS_RouteHop_set_channel_features"))) TS_RouteHop_set_channel_features(uint64_t this_ptr, uint64_t val) {
46217 LDKRouteHop this_ptr_conv;
46218 this_ptr_conv.inner = untag_ptr(this_ptr);
46219 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46221 this_ptr_conv.is_owned = false;
46222 LDKChannelFeatures val_conv;
46223 val_conv.inner = untag_ptr(val);
46224 val_conv.is_owned = ptr_is_owned(val);
46225 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46226 val_conv = ChannelFeatures_clone(&val_conv);
46227 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
46230 int64_t __attribute__((export_name("TS_RouteHop_get_fee_msat"))) TS_RouteHop_get_fee_msat(uint64_t this_ptr) {
46231 LDKRouteHop this_ptr_conv;
46232 this_ptr_conv.inner = untag_ptr(this_ptr);
46233 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46235 this_ptr_conv.is_owned = false;
46236 int64_t ret_conv = RouteHop_get_fee_msat(&this_ptr_conv);
46240 void __attribute__((export_name("TS_RouteHop_set_fee_msat"))) TS_RouteHop_set_fee_msat(uint64_t this_ptr, int64_t val) {
46241 LDKRouteHop this_ptr_conv;
46242 this_ptr_conv.inner = untag_ptr(this_ptr);
46243 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46245 this_ptr_conv.is_owned = false;
46246 RouteHop_set_fee_msat(&this_ptr_conv, val);
46249 int32_t __attribute__((export_name("TS_RouteHop_get_cltv_expiry_delta"))) TS_RouteHop_get_cltv_expiry_delta(uint64_t this_ptr) {
46250 LDKRouteHop this_ptr_conv;
46251 this_ptr_conv.inner = untag_ptr(this_ptr);
46252 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46253 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46254 this_ptr_conv.is_owned = false;
46255 int32_t ret_conv = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
46259 void __attribute__((export_name("TS_RouteHop_set_cltv_expiry_delta"))) TS_RouteHop_set_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
46260 LDKRouteHop this_ptr_conv;
46261 this_ptr_conv.inner = untag_ptr(this_ptr);
46262 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46264 this_ptr_conv.is_owned = false;
46265 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
46268 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) {
46269 LDKPublicKey pubkey_arg_ref;
46270 CHECK(pubkey_arg->arr_len == 33);
46271 memcpy(pubkey_arg_ref.compressed_form, pubkey_arg->elems, 33); FREE(pubkey_arg);
46272 LDKNodeFeatures node_features_arg_conv;
46273 node_features_arg_conv.inner = untag_ptr(node_features_arg);
46274 node_features_arg_conv.is_owned = ptr_is_owned(node_features_arg);
46275 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
46276 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
46277 LDKChannelFeatures channel_features_arg_conv;
46278 channel_features_arg_conv.inner = untag_ptr(channel_features_arg);
46279 channel_features_arg_conv.is_owned = ptr_is_owned(channel_features_arg);
46280 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
46281 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
46282 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);
46283 uint64_t ret_ref = 0;
46284 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46285 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46289 static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
46290 LDKRouteHop ret_var = RouteHop_clone(arg);
46291 uint64_t ret_ref = 0;
46292 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46293 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46296 int64_t __attribute__((export_name("TS_RouteHop_clone_ptr"))) TS_RouteHop_clone_ptr(uint64_t arg) {
46297 LDKRouteHop arg_conv;
46298 arg_conv.inner = untag_ptr(arg);
46299 arg_conv.is_owned = ptr_is_owned(arg);
46300 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46301 arg_conv.is_owned = false;
46302 int64_t ret_conv = RouteHop_clone_ptr(&arg_conv);
46306 uint64_t __attribute__((export_name("TS_RouteHop_clone"))) TS_RouteHop_clone(uint64_t orig) {
46307 LDKRouteHop orig_conv;
46308 orig_conv.inner = untag_ptr(orig);
46309 orig_conv.is_owned = ptr_is_owned(orig);
46310 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46311 orig_conv.is_owned = false;
46312 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
46313 uint64_t ret_ref = 0;
46314 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46315 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46319 int64_t __attribute__((export_name("TS_RouteHop_hash"))) TS_RouteHop_hash(uint64_t o) {
46320 LDKRouteHop o_conv;
46321 o_conv.inner = untag_ptr(o);
46322 o_conv.is_owned = ptr_is_owned(o);
46323 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46324 o_conv.is_owned = false;
46325 int64_t ret_conv = RouteHop_hash(&o_conv);
46329 jboolean __attribute__((export_name("TS_RouteHop_eq"))) TS_RouteHop_eq(uint64_t a, uint64_t b) {
46330 LDKRouteHop a_conv;
46331 a_conv.inner = untag_ptr(a);
46332 a_conv.is_owned = ptr_is_owned(a);
46333 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46334 a_conv.is_owned = false;
46335 LDKRouteHop b_conv;
46336 b_conv.inner = untag_ptr(b);
46337 b_conv.is_owned = ptr_is_owned(b);
46338 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46339 b_conv.is_owned = false;
46340 jboolean ret_conv = RouteHop_eq(&a_conv, &b_conv);
46344 int8_tArray __attribute__((export_name("TS_RouteHop_write"))) TS_RouteHop_write(uint64_t obj) {
46345 LDKRouteHop obj_conv;
46346 obj_conv.inner = untag_ptr(obj);
46347 obj_conv.is_owned = ptr_is_owned(obj);
46348 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46349 obj_conv.is_owned = false;
46350 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
46351 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46352 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46353 CVec_u8Z_free(ret_var);
46357 uint64_t __attribute__((export_name("TS_RouteHop_read"))) TS_RouteHop_read(int8_tArray ser) {
46358 LDKu8slice ser_ref;
46359 ser_ref.datalen = ser->arr_len;
46360 ser_ref.data = ser->elems;
46361 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
46362 *ret_conv = RouteHop_read(ser_ref);
46364 return tag_ptr(ret_conv, true);
46367 void __attribute__((export_name("TS_BlindedTail_free"))) TS_BlindedTail_free(uint64_t this_obj) {
46368 LDKBlindedTail this_obj_conv;
46369 this_obj_conv.inner = untag_ptr(this_obj);
46370 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46372 BlindedTail_free(this_obj_conv);
46375 uint64_tArray __attribute__((export_name("TS_BlindedTail_get_hops"))) TS_BlindedTail_get_hops(uint64_t this_ptr) {
46376 LDKBlindedTail this_ptr_conv;
46377 this_ptr_conv.inner = untag_ptr(this_ptr);
46378 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46379 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46380 this_ptr_conv.is_owned = false;
46381 LDKCVec_BlindedHopZ ret_var = BlindedTail_get_hops(&this_ptr_conv);
46382 uint64_tArray ret_arr = NULL;
46383 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46384 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46385 for (size_t m = 0; m < ret_var.datalen; m++) {
46386 LDKBlindedHop ret_conv_12_var = ret_var.data[m];
46387 uint64_t ret_conv_12_ref = 0;
46388 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_var);
46389 ret_conv_12_ref = tag_ptr(ret_conv_12_var.inner, ret_conv_12_var.is_owned);
46390 ret_arr_ptr[m] = ret_conv_12_ref;
46393 FREE(ret_var.data);
46397 void __attribute__((export_name("TS_BlindedTail_set_hops"))) TS_BlindedTail_set_hops(uint64_t this_ptr, uint64_tArray val) {
46398 LDKBlindedTail this_ptr_conv;
46399 this_ptr_conv.inner = untag_ptr(this_ptr);
46400 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46401 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46402 this_ptr_conv.is_owned = false;
46403 LDKCVec_BlindedHopZ val_constr;
46404 val_constr.datalen = val->arr_len;
46405 if (val_constr.datalen > 0)
46406 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
46408 val_constr.data = NULL;
46409 uint64_t* val_vals = val->elems;
46410 for (size_t m = 0; m < val_constr.datalen; m++) {
46411 uint64_t val_conv_12 = val_vals[m];
46412 LDKBlindedHop val_conv_12_conv;
46413 val_conv_12_conv.inner = untag_ptr(val_conv_12);
46414 val_conv_12_conv.is_owned = ptr_is_owned(val_conv_12);
46415 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv);
46416 val_conv_12_conv = BlindedHop_clone(&val_conv_12_conv);
46417 val_constr.data[m] = val_conv_12_conv;
46420 BlindedTail_set_hops(&this_ptr_conv, val_constr);
46423 int8_tArray __attribute__((export_name("TS_BlindedTail_get_blinding_point"))) TS_BlindedTail_get_blinding_point(uint64_t this_ptr) {
46424 LDKBlindedTail this_ptr_conv;
46425 this_ptr_conv.inner = untag_ptr(this_ptr);
46426 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46427 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46428 this_ptr_conv.is_owned = false;
46429 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46430 memcpy(ret_arr->elems, BlindedTail_get_blinding_point(&this_ptr_conv).compressed_form, 33);
46434 void __attribute__((export_name("TS_BlindedTail_set_blinding_point"))) TS_BlindedTail_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
46435 LDKBlindedTail this_ptr_conv;
46436 this_ptr_conv.inner = untag_ptr(this_ptr);
46437 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46439 this_ptr_conv.is_owned = false;
46440 LDKPublicKey val_ref;
46441 CHECK(val->arr_len == 33);
46442 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46443 BlindedTail_set_blinding_point(&this_ptr_conv, val_ref);
46446 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) {
46447 LDKBlindedTail this_ptr_conv;
46448 this_ptr_conv.inner = untag_ptr(this_ptr);
46449 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46450 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46451 this_ptr_conv.is_owned = false;
46452 int32_t ret_conv = BlindedTail_get_excess_final_cltv_expiry_delta(&this_ptr_conv);
46456 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) {
46457 LDKBlindedTail this_ptr_conv;
46458 this_ptr_conv.inner = untag_ptr(this_ptr);
46459 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46460 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46461 this_ptr_conv.is_owned = false;
46462 BlindedTail_set_excess_final_cltv_expiry_delta(&this_ptr_conv, val);
46465 int64_t __attribute__((export_name("TS_BlindedTail_get_final_value_msat"))) TS_BlindedTail_get_final_value_msat(uint64_t this_ptr) {
46466 LDKBlindedTail this_ptr_conv;
46467 this_ptr_conv.inner = untag_ptr(this_ptr);
46468 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46469 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46470 this_ptr_conv.is_owned = false;
46471 int64_t ret_conv = BlindedTail_get_final_value_msat(&this_ptr_conv);
46475 void __attribute__((export_name("TS_BlindedTail_set_final_value_msat"))) TS_BlindedTail_set_final_value_msat(uint64_t this_ptr, int64_t val) {
46476 LDKBlindedTail this_ptr_conv;
46477 this_ptr_conv.inner = untag_ptr(this_ptr);
46478 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46480 this_ptr_conv.is_owned = false;
46481 BlindedTail_set_final_value_msat(&this_ptr_conv, val);
46484 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) {
46485 LDKCVec_BlindedHopZ hops_arg_constr;
46486 hops_arg_constr.datalen = hops_arg->arr_len;
46487 if (hops_arg_constr.datalen > 0)
46488 hops_arg_constr.data = MALLOC(hops_arg_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
46490 hops_arg_constr.data = NULL;
46491 uint64_t* hops_arg_vals = hops_arg->elems;
46492 for (size_t m = 0; m < hops_arg_constr.datalen; m++) {
46493 uint64_t hops_arg_conv_12 = hops_arg_vals[m];
46494 LDKBlindedHop hops_arg_conv_12_conv;
46495 hops_arg_conv_12_conv.inner = untag_ptr(hops_arg_conv_12);
46496 hops_arg_conv_12_conv.is_owned = ptr_is_owned(hops_arg_conv_12);
46497 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_arg_conv_12_conv);
46498 hops_arg_conv_12_conv = BlindedHop_clone(&hops_arg_conv_12_conv);
46499 hops_arg_constr.data[m] = hops_arg_conv_12_conv;
46502 LDKPublicKey blinding_point_arg_ref;
46503 CHECK(blinding_point_arg->arr_len == 33);
46504 memcpy(blinding_point_arg_ref.compressed_form, blinding_point_arg->elems, 33); FREE(blinding_point_arg);
46505 LDKBlindedTail ret_var = BlindedTail_new(hops_arg_constr, blinding_point_arg_ref, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
46506 uint64_t ret_ref = 0;
46507 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46508 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46512 static inline uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg) {
46513 LDKBlindedTail ret_var = BlindedTail_clone(arg);
46514 uint64_t ret_ref = 0;
46515 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46516 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46519 int64_t __attribute__((export_name("TS_BlindedTail_clone_ptr"))) TS_BlindedTail_clone_ptr(uint64_t arg) {
46520 LDKBlindedTail arg_conv;
46521 arg_conv.inner = untag_ptr(arg);
46522 arg_conv.is_owned = ptr_is_owned(arg);
46523 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46524 arg_conv.is_owned = false;
46525 int64_t ret_conv = BlindedTail_clone_ptr(&arg_conv);
46529 uint64_t __attribute__((export_name("TS_BlindedTail_clone"))) TS_BlindedTail_clone(uint64_t orig) {
46530 LDKBlindedTail orig_conv;
46531 orig_conv.inner = untag_ptr(orig);
46532 orig_conv.is_owned = ptr_is_owned(orig);
46533 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46534 orig_conv.is_owned = false;
46535 LDKBlindedTail ret_var = BlindedTail_clone(&orig_conv);
46536 uint64_t ret_ref = 0;
46537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46542 int64_t __attribute__((export_name("TS_BlindedTail_hash"))) TS_BlindedTail_hash(uint64_t o) {
46543 LDKBlindedTail o_conv;
46544 o_conv.inner = untag_ptr(o);
46545 o_conv.is_owned = ptr_is_owned(o);
46546 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46547 o_conv.is_owned = false;
46548 int64_t ret_conv = BlindedTail_hash(&o_conv);
46552 jboolean __attribute__((export_name("TS_BlindedTail_eq"))) TS_BlindedTail_eq(uint64_t a, uint64_t b) {
46553 LDKBlindedTail a_conv;
46554 a_conv.inner = untag_ptr(a);
46555 a_conv.is_owned = ptr_is_owned(a);
46556 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46557 a_conv.is_owned = false;
46558 LDKBlindedTail b_conv;
46559 b_conv.inner = untag_ptr(b);
46560 b_conv.is_owned = ptr_is_owned(b);
46561 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46562 b_conv.is_owned = false;
46563 jboolean ret_conv = BlindedTail_eq(&a_conv, &b_conv);
46567 int8_tArray __attribute__((export_name("TS_BlindedTail_write"))) TS_BlindedTail_write(uint64_t obj) {
46568 LDKBlindedTail obj_conv;
46569 obj_conv.inner = untag_ptr(obj);
46570 obj_conv.is_owned = ptr_is_owned(obj);
46571 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46572 obj_conv.is_owned = false;
46573 LDKCVec_u8Z ret_var = BlindedTail_write(&obj_conv);
46574 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46575 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46576 CVec_u8Z_free(ret_var);
46580 uint64_t __attribute__((export_name("TS_BlindedTail_read"))) TS_BlindedTail_read(int8_tArray ser) {
46581 LDKu8slice ser_ref;
46582 ser_ref.datalen = ser->arr_len;
46583 ser_ref.data = ser->elems;
46584 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
46585 *ret_conv = BlindedTail_read(ser_ref);
46587 return tag_ptr(ret_conv, true);
46590 void __attribute__((export_name("TS_Path_free"))) TS_Path_free(uint64_t this_obj) {
46591 LDKPath this_obj_conv;
46592 this_obj_conv.inner = untag_ptr(this_obj);
46593 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46595 Path_free(this_obj_conv);
46598 uint64_tArray __attribute__((export_name("TS_Path_get_hops"))) TS_Path_get_hops(uint64_t this_ptr) {
46599 LDKPath this_ptr_conv;
46600 this_ptr_conv.inner = untag_ptr(this_ptr);
46601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46603 this_ptr_conv.is_owned = false;
46604 LDKCVec_RouteHopZ ret_var = Path_get_hops(&this_ptr_conv);
46605 uint64_tArray ret_arr = NULL;
46606 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46607 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46608 for (size_t k = 0; k < ret_var.datalen; k++) {
46609 LDKRouteHop ret_conv_10_var = ret_var.data[k];
46610 uint64_t ret_conv_10_ref = 0;
46611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
46612 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
46613 ret_arr_ptr[k] = ret_conv_10_ref;
46616 FREE(ret_var.data);
46620 void __attribute__((export_name("TS_Path_set_hops"))) TS_Path_set_hops(uint64_t this_ptr, uint64_tArray val) {
46621 LDKPath this_ptr_conv;
46622 this_ptr_conv.inner = untag_ptr(this_ptr);
46623 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46624 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46625 this_ptr_conv.is_owned = false;
46626 LDKCVec_RouteHopZ val_constr;
46627 val_constr.datalen = val->arr_len;
46628 if (val_constr.datalen > 0)
46629 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
46631 val_constr.data = NULL;
46632 uint64_t* val_vals = val->elems;
46633 for (size_t k = 0; k < val_constr.datalen; k++) {
46634 uint64_t val_conv_10 = val_vals[k];
46635 LDKRouteHop val_conv_10_conv;
46636 val_conv_10_conv.inner = untag_ptr(val_conv_10);
46637 val_conv_10_conv.is_owned = ptr_is_owned(val_conv_10);
46638 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_10_conv);
46639 val_conv_10_conv = RouteHop_clone(&val_conv_10_conv);
46640 val_constr.data[k] = val_conv_10_conv;
46643 Path_set_hops(&this_ptr_conv, val_constr);
46646 uint64_t __attribute__((export_name("TS_Path_get_blinded_tail"))) TS_Path_get_blinded_tail(uint64_t this_ptr) {
46647 LDKPath this_ptr_conv;
46648 this_ptr_conv.inner = untag_ptr(this_ptr);
46649 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46650 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46651 this_ptr_conv.is_owned = false;
46652 LDKBlindedTail ret_var = Path_get_blinded_tail(&this_ptr_conv);
46653 uint64_t ret_ref = 0;
46654 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46655 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46659 void __attribute__((export_name("TS_Path_set_blinded_tail"))) TS_Path_set_blinded_tail(uint64_t this_ptr, uint64_t val) {
46660 LDKPath this_ptr_conv;
46661 this_ptr_conv.inner = untag_ptr(this_ptr);
46662 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46664 this_ptr_conv.is_owned = false;
46665 LDKBlindedTail val_conv;
46666 val_conv.inner = untag_ptr(val);
46667 val_conv.is_owned = ptr_is_owned(val);
46668 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46669 val_conv = BlindedTail_clone(&val_conv);
46670 Path_set_blinded_tail(&this_ptr_conv, val_conv);
46673 uint64_t __attribute__((export_name("TS_Path_new"))) TS_Path_new(uint64_tArray hops_arg, uint64_t blinded_tail_arg) {
46674 LDKCVec_RouteHopZ hops_arg_constr;
46675 hops_arg_constr.datalen = hops_arg->arr_len;
46676 if (hops_arg_constr.datalen > 0)
46677 hops_arg_constr.data = MALLOC(hops_arg_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
46679 hops_arg_constr.data = NULL;
46680 uint64_t* hops_arg_vals = hops_arg->elems;
46681 for (size_t k = 0; k < hops_arg_constr.datalen; k++) {
46682 uint64_t hops_arg_conv_10 = hops_arg_vals[k];
46683 LDKRouteHop hops_arg_conv_10_conv;
46684 hops_arg_conv_10_conv.inner = untag_ptr(hops_arg_conv_10);
46685 hops_arg_conv_10_conv.is_owned = ptr_is_owned(hops_arg_conv_10);
46686 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_arg_conv_10_conv);
46687 hops_arg_conv_10_conv = RouteHop_clone(&hops_arg_conv_10_conv);
46688 hops_arg_constr.data[k] = hops_arg_conv_10_conv;
46691 LDKBlindedTail blinded_tail_arg_conv;
46692 blinded_tail_arg_conv.inner = untag_ptr(blinded_tail_arg);
46693 blinded_tail_arg_conv.is_owned = ptr_is_owned(blinded_tail_arg);
46694 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_tail_arg_conv);
46695 blinded_tail_arg_conv = BlindedTail_clone(&blinded_tail_arg_conv);
46696 LDKPath ret_var = Path_new(hops_arg_constr, blinded_tail_arg_conv);
46697 uint64_t ret_ref = 0;
46698 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46699 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46703 static inline uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg) {
46704 LDKPath ret_var = Path_clone(arg);
46705 uint64_t ret_ref = 0;
46706 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46707 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46710 int64_t __attribute__((export_name("TS_Path_clone_ptr"))) TS_Path_clone_ptr(uint64_t arg) {
46712 arg_conv.inner = untag_ptr(arg);
46713 arg_conv.is_owned = ptr_is_owned(arg);
46714 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46715 arg_conv.is_owned = false;
46716 int64_t ret_conv = Path_clone_ptr(&arg_conv);
46720 uint64_t __attribute__((export_name("TS_Path_clone"))) TS_Path_clone(uint64_t orig) {
46722 orig_conv.inner = untag_ptr(orig);
46723 orig_conv.is_owned = ptr_is_owned(orig);
46724 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46725 orig_conv.is_owned = false;
46726 LDKPath ret_var = Path_clone(&orig_conv);
46727 uint64_t ret_ref = 0;
46728 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46729 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46733 int64_t __attribute__((export_name("TS_Path_hash"))) TS_Path_hash(uint64_t o) {
46735 o_conv.inner = untag_ptr(o);
46736 o_conv.is_owned = ptr_is_owned(o);
46737 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46738 o_conv.is_owned = false;
46739 int64_t ret_conv = Path_hash(&o_conv);
46743 jboolean __attribute__((export_name("TS_Path_eq"))) TS_Path_eq(uint64_t a, uint64_t b) {
46745 a_conv.inner = untag_ptr(a);
46746 a_conv.is_owned = ptr_is_owned(a);
46747 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46748 a_conv.is_owned = false;
46750 b_conv.inner = untag_ptr(b);
46751 b_conv.is_owned = ptr_is_owned(b);
46752 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46753 b_conv.is_owned = false;
46754 jboolean ret_conv = Path_eq(&a_conv, &b_conv);
46758 int64_t __attribute__((export_name("TS_Path_fee_msat"))) TS_Path_fee_msat(uint64_t this_arg) {
46759 LDKPath this_arg_conv;
46760 this_arg_conv.inner = untag_ptr(this_arg);
46761 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46763 this_arg_conv.is_owned = false;
46764 int64_t ret_conv = Path_fee_msat(&this_arg_conv);
46768 int64_t __attribute__((export_name("TS_Path_final_value_msat"))) TS_Path_final_value_msat(uint64_t this_arg) {
46769 LDKPath this_arg_conv;
46770 this_arg_conv.inner = untag_ptr(this_arg);
46771 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46772 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46773 this_arg_conv.is_owned = false;
46774 int64_t ret_conv = Path_final_value_msat(&this_arg_conv);
46778 uint64_t __attribute__((export_name("TS_Path_final_cltv_expiry_delta"))) TS_Path_final_cltv_expiry_delta(uint64_t this_arg) {
46779 LDKPath this_arg_conv;
46780 this_arg_conv.inner = untag_ptr(this_arg);
46781 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46782 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46783 this_arg_conv.is_owned = false;
46784 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
46785 *ret_copy = Path_final_cltv_expiry_delta(&this_arg_conv);
46786 uint64_t ret_ref = tag_ptr(ret_copy, true);
46790 void __attribute__((export_name("TS_Route_free"))) TS_Route_free(uint64_t this_obj) {
46791 LDKRoute this_obj_conv;
46792 this_obj_conv.inner = untag_ptr(this_obj);
46793 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46795 Route_free(this_obj_conv);
46798 uint64_tArray __attribute__((export_name("TS_Route_get_paths"))) TS_Route_get_paths(uint64_t this_ptr) {
46799 LDKRoute this_ptr_conv;
46800 this_ptr_conv.inner = untag_ptr(this_ptr);
46801 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46802 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46803 this_ptr_conv.is_owned = false;
46804 LDKCVec_PathZ ret_var = Route_get_paths(&this_ptr_conv);
46805 uint64_tArray ret_arr = NULL;
46806 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46807 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46808 for (size_t g = 0; g < ret_var.datalen; g++) {
46809 LDKPath ret_conv_6_var = ret_var.data[g];
46810 uint64_t ret_conv_6_ref = 0;
46811 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_6_var);
46812 ret_conv_6_ref = tag_ptr(ret_conv_6_var.inner, ret_conv_6_var.is_owned);
46813 ret_arr_ptr[g] = ret_conv_6_ref;
46816 FREE(ret_var.data);
46820 void __attribute__((export_name("TS_Route_set_paths"))) TS_Route_set_paths(uint64_t this_ptr, uint64_tArray val) {
46821 LDKRoute this_ptr_conv;
46822 this_ptr_conv.inner = untag_ptr(this_ptr);
46823 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46824 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46825 this_ptr_conv.is_owned = false;
46826 LDKCVec_PathZ val_constr;
46827 val_constr.datalen = val->arr_len;
46828 if (val_constr.datalen > 0)
46829 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
46831 val_constr.data = NULL;
46832 uint64_t* val_vals = val->elems;
46833 for (size_t g = 0; g < val_constr.datalen; g++) {
46834 uint64_t val_conv_6 = val_vals[g];
46835 LDKPath val_conv_6_conv;
46836 val_conv_6_conv.inner = untag_ptr(val_conv_6);
46837 val_conv_6_conv.is_owned = ptr_is_owned(val_conv_6);
46838 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_6_conv);
46839 val_conv_6_conv = Path_clone(&val_conv_6_conv);
46840 val_constr.data[g] = val_conv_6_conv;
46843 Route_set_paths(&this_ptr_conv, val_constr);
46846 uint64_t __attribute__((export_name("TS_Route_get_payment_params"))) TS_Route_get_payment_params(uint64_t this_ptr) {
46847 LDKRoute this_ptr_conv;
46848 this_ptr_conv.inner = untag_ptr(this_ptr);
46849 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46850 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46851 this_ptr_conv.is_owned = false;
46852 LDKPaymentParameters ret_var = Route_get_payment_params(&this_ptr_conv);
46853 uint64_t ret_ref = 0;
46854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46855 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46859 void __attribute__((export_name("TS_Route_set_payment_params"))) TS_Route_set_payment_params(uint64_t this_ptr, uint64_t val) {
46860 LDKRoute this_ptr_conv;
46861 this_ptr_conv.inner = untag_ptr(this_ptr);
46862 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46863 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46864 this_ptr_conv.is_owned = false;
46865 LDKPaymentParameters val_conv;
46866 val_conv.inner = untag_ptr(val);
46867 val_conv.is_owned = ptr_is_owned(val);
46868 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
46869 val_conv = PaymentParameters_clone(&val_conv);
46870 Route_set_payment_params(&this_ptr_conv, val_conv);
46873 uint64_t __attribute__((export_name("TS_Route_new"))) TS_Route_new(uint64_tArray paths_arg, uint64_t payment_params_arg) {
46874 LDKCVec_PathZ paths_arg_constr;
46875 paths_arg_constr.datalen = paths_arg->arr_len;
46876 if (paths_arg_constr.datalen > 0)
46877 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
46879 paths_arg_constr.data = NULL;
46880 uint64_t* paths_arg_vals = paths_arg->elems;
46881 for (size_t g = 0; g < paths_arg_constr.datalen; g++) {
46882 uint64_t paths_arg_conv_6 = paths_arg_vals[g];
46883 LDKPath paths_arg_conv_6_conv;
46884 paths_arg_conv_6_conv.inner = untag_ptr(paths_arg_conv_6);
46885 paths_arg_conv_6_conv.is_owned = ptr_is_owned(paths_arg_conv_6);
46886 CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_6_conv);
46887 paths_arg_conv_6_conv = Path_clone(&paths_arg_conv_6_conv);
46888 paths_arg_constr.data[g] = paths_arg_conv_6_conv;
46891 LDKPaymentParameters payment_params_arg_conv;
46892 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
46893 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
46894 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
46895 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
46896 LDKRoute ret_var = Route_new(paths_arg_constr, payment_params_arg_conv);
46897 uint64_t ret_ref = 0;
46898 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46899 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46903 static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
46904 LDKRoute ret_var = Route_clone(arg);
46905 uint64_t ret_ref = 0;
46906 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46907 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46910 int64_t __attribute__((export_name("TS_Route_clone_ptr"))) TS_Route_clone_ptr(uint64_t arg) {
46912 arg_conv.inner = untag_ptr(arg);
46913 arg_conv.is_owned = ptr_is_owned(arg);
46914 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46915 arg_conv.is_owned = false;
46916 int64_t ret_conv = Route_clone_ptr(&arg_conv);
46920 uint64_t __attribute__((export_name("TS_Route_clone"))) TS_Route_clone(uint64_t orig) {
46921 LDKRoute orig_conv;
46922 orig_conv.inner = untag_ptr(orig);
46923 orig_conv.is_owned = ptr_is_owned(orig);
46924 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46925 orig_conv.is_owned = false;
46926 LDKRoute ret_var = Route_clone(&orig_conv);
46927 uint64_t ret_ref = 0;
46928 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46929 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46933 int64_t __attribute__((export_name("TS_Route_hash"))) TS_Route_hash(uint64_t o) {
46935 o_conv.inner = untag_ptr(o);
46936 o_conv.is_owned = ptr_is_owned(o);
46937 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
46938 o_conv.is_owned = false;
46939 int64_t ret_conv = Route_hash(&o_conv);
46943 jboolean __attribute__((export_name("TS_Route_eq"))) TS_Route_eq(uint64_t a, uint64_t b) {
46945 a_conv.inner = untag_ptr(a);
46946 a_conv.is_owned = ptr_is_owned(a);
46947 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
46948 a_conv.is_owned = false;
46950 b_conv.inner = untag_ptr(b);
46951 b_conv.is_owned = ptr_is_owned(b);
46952 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
46953 b_conv.is_owned = false;
46954 jboolean ret_conv = Route_eq(&a_conv, &b_conv);
46958 int64_t __attribute__((export_name("TS_Route_get_total_fees"))) TS_Route_get_total_fees(uint64_t this_arg) {
46959 LDKRoute this_arg_conv;
46960 this_arg_conv.inner = untag_ptr(this_arg);
46961 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46963 this_arg_conv.is_owned = false;
46964 int64_t ret_conv = Route_get_total_fees(&this_arg_conv);
46968 int64_t __attribute__((export_name("TS_Route_get_total_amount"))) TS_Route_get_total_amount(uint64_t this_arg) {
46969 LDKRoute this_arg_conv;
46970 this_arg_conv.inner = untag_ptr(this_arg);
46971 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46972 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46973 this_arg_conv.is_owned = false;
46974 int64_t ret_conv = Route_get_total_amount(&this_arg_conv);
46978 int8_tArray __attribute__((export_name("TS_Route_write"))) TS_Route_write(uint64_t obj) {
46980 obj_conv.inner = untag_ptr(obj);
46981 obj_conv.is_owned = ptr_is_owned(obj);
46982 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46983 obj_conv.is_owned = false;
46984 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
46985 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46986 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46987 CVec_u8Z_free(ret_var);
46991 uint64_t __attribute__((export_name("TS_Route_read"))) TS_Route_read(int8_tArray ser) {
46992 LDKu8slice ser_ref;
46993 ser_ref.datalen = ser->arr_len;
46994 ser_ref.data = ser->elems;
46995 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
46996 *ret_conv = Route_read(ser_ref);
46998 return tag_ptr(ret_conv, true);
47001 void __attribute__((export_name("TS_RouteParameters_free"))) TS_RouteParameters_free(uint64_t this_obj) {
47002 LDKRouteParameters this_obj_conv;
47003 this_obj_conv.inner = untag_ptr(this_obj);
47004 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47006 RouteParameters_free(this_obj_conv);
47009 uint64_t __attribute__((export_name("TS_RouteParameters_get_payment_params"))) TS_RouteParameters_get_payment_params(uint64_t this_ptr) {
47010 LDKRouteParameters this_ptr_conv;
47011 this_ptr_conv.inner = untag_ptr(this_ptr);
47012 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47014 this_ptr_conv.is_owned = false;
47015 LDKPaymentParameters ret_var = RouteParameters_get_payment_params(&this_ptr_conv);
47016 uint64_t ret_ref = 0;
47017 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47018 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47022 void __attribute__((export_name("TS_RouteParameters_set_payment_params"))) TS_RouteParameters_set_payment_params(uint64_t this_ptr, uint64_t val) {
47023 LDKRouteParameters this_ptr_conv;
47024 this_ptr_conv.inner = untag_ptr(this_ptr);
47025 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47026 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47027 this_ptr_conv.is_owned = false;
47028 LDKPaymentParameters val_conv;
47029 val_conv.inner = untag_ptr(val);
47030 val_conv.is_owned = ptr_is_owned(val);
47031 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47032 val_conv = PaymentParameters_clone(&val_conv);
47033 RouteParameters_set_payment_params(&this_ptr_conv, val_conv);
47036 int64_t __attribute__((export_name("TS_RouteParameters_get_final_value_msat"))) TS_RouteParameters_get_final_value_msat(uint64_t this_ptr) {
47037 LDKRouteParameters this_ptr_conv;
47038 this_ptr_conv.inner = untag_ptr(this_ptr);
47039 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47040 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47041 this_ptr_conv.is_owned = false;
47042 int64_t ret_conv = RouteParameters_get_final_value_msat(&this_ptr_conv);
47046 void __attribute__((export_name("TS_RouteParameters_set_final_value_msat"))) TS_RouteParameters_set_final_value_msat(uint64_t this_ptr, int64_t val) {
47047 LDKRouteParameters this_ptr_conv;
47048 this_ptr_conv.inner = untag_ptr(this_ptr);
47049 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47050 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47051 this_ptr_conv.is_owned = false;
47052 RouteParameters_set_final_value_msat(&this_ptr_conv, val);
47055 uint64_t __attribute__((export_name("TS_RouteParameters_new"))) TS_RouteParameters_new(uint64_t payment_params_arg, int64_t final_value_msat_arg) {
47056 LDKPaymentParameters payment_params_arg_conv;
47057 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
47058 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
47059 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
47060 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
47061 LDKRouteParameters ret_var = RouteParameters_new(payment_params_arg_conv, final_value_msat_arg);
47062 uint64_t ret_ref = 0;
47063 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47064 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47068 static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
47069 LDKRouteParameters ret_var = RouteParameters_clone(arg);
47070 uint64_t ret_ref = 0;
47071 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47072 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47075 int64_t __attribute__((export_name("TS_RouteParameters_clone_ptr"))) TS_RouteParameters_clone_ptr(uint64_t arg) {
47076 LDKRouteParameters arg_conv;
47077 arg_conv.inner = untag_ptr(arg);
47078 arg_conv.is_owned = ptr_is_owned(arg);
47079 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47080 arg_conv.is_owned = false;
47081 int64_t ret_conv = RouteParameters_clone_ptr(&arg_conv);
47085 uint64_t __attribute__((export_name("TS_RouteParameters_clone"))) TS_RouteParameters_clone(uint64_t orig) {
47086 LDKRouteParameters orig_conv;
47087 orig_conv.inner = untag_ptr(orig);
47088 orig_conv.is_owned = ptr_is_owned(orig);
47089 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47090 orig_conv.is_owned = false;
47091 LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
47092 uint64_t ret_ref = 0;
47093 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47094 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47098 jboolean __attribute__((export_name("TS_RouteParameters_eq"))) TS_RouteParameters_eq(uint64_t a, uint64_t b) {
47099 LDKRouteParameters a_conv;
47100 a_conv.inner = untag_ptr(a);
47101 a_conv.is_owned = ptr_is_owned(a);
47102 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47103 a_conv.is_owned = false;
47104 LDKRouteParameters b_conv;
47105 b_conv.inner = untag_ptr(b);
47106 b_conv.is_owned = ptr_is_owned(b);
47107 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47108 b_conv.is_owned = false;
47109 jboolean ret_conv = RouteParameters_eq(&a_conv, &b_conv);
47113 int8_tArray __attribute__((export_name("TS_RouteParameters_write"))) TS_RouteParameters_write(uint64_t obj) {
47114 LDKRouteParameters obj_conv;
47115 obj_conv.inner = untag_ptr(obj);
47116 obj_conv.is_owned = ptr_is_owned(obj);
47117 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47118 obj_conv.is_owned = false;
47119 LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
47120 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47121 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47122 CVec_u8Z_free(ret_var);
47126 uint64_t __attribute__((export_name("TS_RouteParameters_read"))) TS_RouteParameters_read(int8_tArray ser) {
47127 LDKu8slice ser_ref;
47128 ser_ref.datalen = ser->arr_len;
47129 ser_ref.data = ser->elems;
47130 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
47131 *ret_conv = RouteParameters_read(ser_ref);
47133 return tag_ptr(ret_conv, true);
47136 void __attribute__((export_name("TS_PaymentParameters_free"))) TS_PaymentParameters_free(uint64_t this_obj) {
47137 LDKPaymentParameters this_obj_conv;
47138 this_obj_conv.inner = untag_ptr(this_obj);
47139 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47141 PaymentParameters_free(this_obj_conv);
47144 int8_tArray __attribute__((export_name("TS_PaymentParameters_get_payee_pubkey"))) TS_PaymentParameters_get_payee_pubkey(uint64_t this_ptr) {
47145 LDKPaymentParameters this_ptr_conv;
47146 this_ptr_conv.inner = untag_ptr(this_ptr);
47147 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47149 this_ptr_conv.is_owned = false;
47150 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47151 memcpy(ret_arr->elems, PaymentParameters_get_payee_pubkey(&this_ptr_conv).compressed_form, 33);
47155 void __attribute__((export_name("TS_PaymentParameters_set_payee_pubkey"))) TS_PaymentParameters_set_payee_pubkey(uint64_t this_ptr, int8_tArray val) {
47156 LDKPaymentParameters this_ptr_conv;
47157 this_ptr_conv.inner = untag_ptr(this_ptr);
47158 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47160 this_ptr_conv.is_owned = false;
47161 LDKPublicKey val_ref;
47162 CHECK(val->arr_len == 33);
47163 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47164 PaymentParameters_set_payee_pubkey(&this_ptr_conv, val_ref);
47167 uint64_t __attribute__((export_name("TS_PaymentParameters_get_features"))) TS_PaymentParameters_get_features(uint64_t this_ptr) {
47168 LDKPaymentParameters this_ptr_conv;
47169 this_ptr_conv.inner = untag_ptr(this_ptr);
47170 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47171 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47172 this_ptr_conv.is_owned = false;
47173 LDKInvoiceFeatures ret_var = PaymentParameters_get_features(&this_ptr_conv);
47174 uint64_t ret_ref = 0;
47175 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47176 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47180 void __attribute__((export_name("TS_PaymentParameters_set_features"))) TS_PaymentParameters_set_features(uint64_t this_ptr, uint64_t val) {
47181 LDKPaymentParameters this_ptr_conv;
47182 this_ptr_conv.inner = untag_ptr(this_ptr);
47183 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47185 this_ptr_conv.is_owned = false;
47186 LDKInvoiceFeatures val_conv;
47187 val_conv.inner = untag_ptr(val);
47188 val_conv.is_owned = ptr_is_owned(val);
47189 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47190 val_conv = InvoiceFeatures_clone(&val_conv);
47191 PaymentParameters_set_features(&this_ptr_conv, val_conv);
47194 uint64_t __attribute__((export_name("TS_PaymentParameters_get_route_hints"))) TS_PaymentParameters_get_route_hints(uint64_t this_ptr) {
47195 LDKPaymentParameters this_ptr_conv;
47196 this_ptr_conv.inner = untag_ptr(this_ptr);
47197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47199 this_ptr_conv.is_owned = false;
47200 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47201 *ret_copy = PaymentParameters_get_route_hints(&this_ptr_conv);
47202 uint64_t ret_ref = tag_ptr(ret_copy, true);
47206 void __attribute__((export_name("TS_PaymentParameters_set_route_hints"))) TS_PaymentParameters_set_route_hints(uint64_t this_ptr, uint64_t val) {
47207 LDKPaymentParameters this_ptr_conv;
47208 this_ptr_conv.inner = untag_ptr(this_ptr);
47209 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47211 this_ptr_conv.is_owned = false;
47212 void* val_ptr = untag_ptr(val);
47213 CHECK_ACCESS(val_ptr);
47214 LDKHints val_conv = *(LDKHints*)(val_ptr);
47215 val_conv = Hints_clone((LDKHints*)untag_ptr(val));
47216 PaymentParameters_set_route_hints(&this_ptr_conv, val_conv);
47219 uint64_t __attribute__((export_name("TS_PaymentParameters_get_expiry_time"))) TS_PaymentParameters_get_expiry_time(uint64_t this_ptr) {
47220 LDKPaymentParameters this_ptr_conv;
47221 this_ptr_conv.inner = untag_ptr(this_ptr);
47222 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47223 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47224 this_ptr_conv.is_owned = false;
47225 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47226 *ret_copy = PaymentParameters_get_expiry_time(&this_ptr_conv);
47227 uint64_t ret_ref = tag_ptr(ret_copy, true);
47231 void __attribute__((export_name("TS_PaymentParameters_set_expiry_time"))) TS_PaymentParameters_set_expiry_time(uint64_t this_ptr, uint64_t val) {
47232 LDKPaymentParameters this_ptr_conv;
47233 this_ptr_conv.inner = untag_ptr(this_ptr);
47234 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47235 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47236 this_ptr_conv.is_owned = false;
47237 void* val_ptr = untag_ptr(val);
47238 CHECK_ACCESS(val_ptr);
47239 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
47240 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
47241 PaymentParameters_set_expiry_time(&this_ptr_conv, val_conv);
47244 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) {
47245 LDKPaymentParameters this_ptr_conv;
47246 this_ptr_conv.inner = untag_ptr(this_ptr);
47247 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47249 this_ptr_conv.is_owned = false;
47250 int32_t ret_conv = PaymentParameters_get_max_total_cltv_expiry_delta(&this_ptr_conv);
47254 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) {
47255 LDKPaymentParameters this_ptr_conv;
47256 this_ptr_conv.inner = untag_ptr(this_ptr);
47257 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47259 this_ptr_conv.is_owned = false;
47260 PaymentParameters_set_max_total_cltv_expiry_delta(&this_ptr_conv, val);
47263 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_path_count"))) TS_PaymentParameters_get_max_path_count(uint64_t this_ptr) {
47264 LDKPaymentParameters this_ptr_conv;
47265 this_ptr_conv.inner = untag_ptr(this_ptr);
47266 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47268 this_ptr_conv.is_owned = false;
47269 int8_t ret_conv = PaymentParameters_get_max_path_count(&this_ptr_conv);
47273 void __attribute__((export_name("TS_PaymentParameters_set_max_path_count"))) TS_PaymentParameters_set_max_path_count(uint64_t this_ptr, int8_t val) {
47274 LDKPaymentParameters this_ptr_conv;
47275 this_ptr_conv.inner = untag_ptr(this_ptr);
47276 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47278 this_ptr_conv.is_owned = false;
47279 PaymentParameters_set_max_path_count(&this_ptr_conv, val);
47282 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) {
47283 LDKPaymentParameters this_ptr_conv;
47284 this_ptr_conv.inner = untag_ptr(this_ptr);
47285 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47287 this_ptr_conv.is_owned = false;
47288 int8_t ret_conv = PaymentParameters_get_max_channel_saturation_power_of_half(&this_ptr_conv);
47292 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) {
47293 LDKPaymentParameters this_ptr_conv;
47294 this_ptr_conv.inner = untag_ptr(this_ptr);
47295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47297 this_ptr_conv.is_owned = false;
47298 PaymentParameters_set_max_channel_saturation_power_of_half(&this_ptr_conv, val);
47301 int64_tArray __attribute__((export_name("TS_PaymentParameters_get_previously_failed_channels"))) TS_PaymentParameters_get_previously_failed_channels(uint64_t this_ptr) {
47302 LDKPaymentParameters this_ptr_conv;
47303 this_ptr_conv.inner = untag_ptr(this_ptr);
47304 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47306 this_ptr_conv.is_owned = false;
47307 LDKCVec_u64Z ret_var = PaymentParameters_get_previously_failed_channels(&this_ptr_conv);
47308 int64_tArray ret_arr = NULL;
47309 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
47310 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
47311 for (size_t i = 0; i < ret_var.datalen; i++) {
47312 int64_t ret_conv_8_conv = ret_var.data[i];
47313 ret_arr_ptr[i] = ret_conv_8_conv;
47316 FREE(ret_var.data);
47320 void __attribute__((export_name("TS_PaymentParameters_set_previously_failed_channels"))) TS_PaymentParameters_set_previously_failed_channels(uint64_t this_ptr, int64_tArray val) {
47321 LDKPaymentParameters this_ptr_conv;
47322 this_ptr_conv.inner = untag_ptr(this_ptr);
47323 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47325 this_ptr_conv.is_owned = false;
47326 LDKCVec_u64Z val_constr;
47327 val_constr.datalen = val->arr_len;
47328 if (val_constr.datalen > 0)
47329 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
47331 val_constr.data = NULL;
47332 int64_t* val_vals = val->elems;
47333 for (size_t i = 0; i < val_constr.datalen; i++) {
47334 int64_t val_conv_8 = val_vals[i];
47335 val_constr.data[i] = val_conv_8;
47338 PaymentParameters_set_previously_failed_channels(&this_ptr_conv, val_constr);
47341 int32_t __attribute__((export_name("TS_PaymentParameters_get_final_cltv_expiry_delta"))) TS_PaymentParameters_get_final_cltv_expiry_delta(uint64_t this_ptr) {
47342 LDKPaymentParameters this_ptr_conv;
47343 this_ptr_conv.inner = untag_ptr(this_ptr);
47344 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47346 this_ptr_conv.is_owned = false;
47347 int32_t ret_conv = PaymentParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
47351 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) {
47352 LDKPaymentParameters this_ptr_conv;
47353 this_ptr_conv.inner = untag_ptr(this_ptr);
47354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47356 this_ptr_conv.is_owned = false;
47357 PaymentParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
47360 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) {
47361 LDKPublicKey payee_pubkey_arg_ref;
47362 CHECK(payee_pubkey_arg->arr_len == 33);
47363 memcpy(payee_pubkey_arg_ref.compressed_form, payee_pubkey_arg->elems, 33); FREE(payee_pubkey_arg);
47364 LDKInvoiceFeatures features_arg_conv;
47365 features_arg_conv.inner = untag_ptr(features_arg);
47366 features_arg_conv.is_owned = ptr_is_owned(features_arg);
47367 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
47368 features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
47369 void* route_hints_arg_ptr = untag_ptr(route_hints_arg);
47370 CHECK_ACCESS(route_hints_arg_ptr);
47371 LDKHints route_hints_arg_conv = *(LDKHints*)(route_hints_arg_ptr);
47372 route_hints_arg_conv = Hints_clone((LDKHints*)untag_ptr(route_hints_arg));
47373 void* expiry_time_arg_ptr = untag_ptr(expiry_time_arg);
47374 CHECK_ACCESS(expiry_time_arg_ptr);
47375 LDKCOption_u64Z expiry_time_arg_conv = *(LDKCOption_u64Z*)(expiry_time_arg_ptr);
47376 expiry_time_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(expiry_time_arg));
47377 LDKCVec_u64Z previously_failed_channels_arg_constr;
47378 previously_failed_channels_arg_constr.datalen = previously_failed_channels_arg->arr_len;
47379 if (previously_failed_channels_arg_constr.datalen > 0)
47380 previously_failed_channels_arg_constr.data = MALLOC(previously_failed_channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
47382 previously_failed_channels_arg_constr.data = NULL;
47383 int64_t* previously_failed_channels_arg_vals = previously_failed_channels_arg->elems;
47384 for (size_t i = 0; i < previously_failed_channels_arg_constr.datalen; i++) {
47385 int64_t previously_failed_channels_arg_conv_8 = previously_failed_channels_arg_vals[i];
47386 previously_failed_channels_arg_constr.data[i] = previously_failed_channels_arg_conv_8;
47388 FREE(previously_failed_channels_arg);
47389 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);
47390 uint64_t ret_ref = 0;
47391 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47392 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47396 static inline uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg) {
47397 LDKPaymentParameters ret_var = PaymentParameters_clone(arg);
47398 uint64_t ret_ref = 0;
47399 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47400 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47403 int64_t __attribute__((export_name("TS_PaymentParameters_clone_ptr"))) TS_PaymentParameters_clone_ptr(uint64_t arg) {
47404 LDKPaymentParameters arg_conv;
47405 arg_conv.inner = untag_ptr(arg);
47406 arg_conv.is_owned = ptr_is_owned(arg);
47407 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47408 arg_conv.is_owned = false;
47409 int64_t ret_conv = PaymentParameters_clone_ptr(&arg_conv);
47413 uint64_t __attribute__((export_name("TS_PaymentParameters_clone"))) TS_PaymentParameters_clone(uint64_t orig) {
47414 LDKPaymentParameters orig_conv;
47415 orig_conv.inner = untag_ptr(orig);
47416 orig_conv.is_owned = ptr_is_owned(orig);
47417 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47418 orig_conv.is_owned = false;
47419 LDKPaymentParameters ret_var = PaymentParameters_clone(&orig_conv);
47420 uint64_t ret_ref = 0;
47421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47426 int64_t __attribute__((export_name("TS_PaymentParameters_hash"))) TS_PaymentParameters_hash(uint64_t o) {
47427 LDKPaymentParameters o_conv;
47428 o_conv.inner = untag_ptr(o);
47429 o_conv.is_owned = ptr_is_owned(o);
47430 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47431 o_conv.is_owned = false;
47432 int64_t ret_conv = PaymentParameters_hash(&o_conv);
47436 jboolean __attribute__((export_name("TS_PaymentParameters_eq"))) TS_PaymentParameters_eq(uint64_t a, uint64_t b) {
47437 LDKPaymentParameters a_conv;
47438 a_conv.inner = untag_ptr(a);
47439 a_conv.is_owned = ptr_is_owned(a);
47440 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47441 a_conv.is_owned = false;
47442 LDKPaymentParameters b_conv;
47443 b_conv.inner = untag_ptr(b);
47444 b_conv.is_owned = ptr_is_owned(b);
47445 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47446 b_conv.is_owned = false;
47447 jboolean ret_conv = PaymentParameters_eq(&a_conv, &b_conv);
47451 int8_tArray __attribute__((export_name("TS_PaymentParameters_write"))) TS_PaymentParameters_write(uint64_t obj) {
47452 LDKPaymentParameters obj_conv;
47453 obj_conv.inner = untag_ptr(obj);
47454 obj_conv.is_owned = ptr_is_owned(obj);
47455 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47456 obj_conv.is_owned = false;
47457 LDKCVec_u8Z ret_var = PaymentParameters_write(&obj_conv);
47458 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47459 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47460 CVec_u8Z_free(ret_var);
47464 uint64_t __attribute__((export_name("TS_PaymentParameters_read"))) TS_PaymentParameters_read(int8_tArray ser, int32_t arg) {
47465 LDKu8slice ser_ref;
47466 ser_ref.datalen = ser->arr_len;
47467 ser_ref.data = ser->elems;
47468 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
47469 *ret_conv = PaymentParameters_read(ser_ref, arg);
47471 return tag_ptr(ret_conv, true);
47474 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) {
47475 LDKPublicKey payee_pubkey_ref;
47476 CHECK(payee_pubkey->arr_len == 33);
47477 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
47478 LDKPaymentParameters ret_var = PaymentParameters_from_node_id(payee_pubkey_ref, final_cltv_expiry_delta);
47479 uint64_t ret_ref = 0;
47480 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47481 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47485 uint64_t __attribute__((export_name("TS_PaymentParameters_for_keysend"))) TS_PaymentParameters_for_keysend(int8_tArray payee_pubkey, int32_t final_cltv_expiry_delta) {
47486 LDKPublicKey payee_pubkey_ref;
47487 CHECK(payee_pubkey->arr_len == 33);
47488 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
47489 LDKPaymentParameters ret_var = PaymentParameters_for_keysend(payee_pubkey_ref, final_cltv_expiry_delta);
47490 uint64_t ret_ref = 0;
47491 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47492 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47496 void __attribute__((export_name("TS_Hints_free"))) TS_Hints_free(uint64_t this_ptr) {
47497 if (!ptr_is_owned(this_ptr)) return;
47498 void* this_ptr_ptr = untag_ptr(this_ptr);
47499 CHECK_ACCESS(this_ptr_ptr);
47500 LDKHints this_ptr_conv = *(LDKHints*)(this_ptr_ptr);
47501 FREE(untag_ptr(this_ptr));
47502 Hints_free(this_ptr_conv);
47505 static inline uint64_t Hints_clone_ptr(LDKHints *NONNULL_PTR arg) {
47506 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47507 *ret_copy = Hints_clone(arg);
47508 uint64_t ret_ref = tag_ptr(ret_copy, true);
47511 int64_t __attribute__((export_name("TS_Hints_clone_ptr"))) TS_Hints_clone_ptr(uint64_t arg) {
47512 LDKHints* arg_conv = (LDKHints*)untag_ptr(arg);
47513 int64_t ret_conv = Hints_clone_ptr(arg_conv);
47517 uint64_t __attribute__((export_name("TS_Hints_clone"))) TS_Hints_clone(uint64_t orig) {
47518 LDKHints* orig_conv = (LDKHints*)untag_ptr(orig);
47519 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47520 *ret_copy = Hints_clone(orig_conv);
47521 uint64_t ret_ref = tag_ptr(ret_copy, true);
47525 uint64_t __attribute__((export_name("TS_Hints_blinded"))) TS_Hints_blinded(uint64_tArray a) {
47526 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ a_constr;
47527 a_constr.datalen = a->arr_len;
47528 if (a_constr.datalen > 0)
47529 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
47531 a_constr.data = NULL;
47532 uint64_t* a_vals = a->elems;
47533 for (size_t l = 0; l < a_constr.datalen; l++) {
47534 uint64_t a_conv_37 = a_vals[l];
47535 void* a_conv_37_ptr = untag_ptr(a_conv_37);
47536 CHECK_ACCESS(a_conv_37_ptr);
47537 LDKC2Tuple_BlindedPayInfoBlindedPathZ a_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(a_conv_37_ptr);
47538 a_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone((LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(a_conv_37));
47539 a_constr.data[l] = a_conv_37_conv;
47542 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47543 *ret_copy = Hints_blinded(a_constr);
47544 uint64_t ret_ref = tag_ptr(ret_copy, true);
47548 uint64_t __attribute__((export_name("TS_Hints_clear"))) TS_Hints_clear(uint64_tArray a) {
47549 LDKCVec_RouteHintZ a_constr;
47550 a_constr.datalen = a->arr_len;
47551 if (a_constr.datalen > 0)
47552 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
47554 a_constr.data = NULL;
47555 uint64_t* a_vals = a->elems;
47556 for (size_t l = 0; l < a_constr.datalen; l++) {
47557 uint64_t a_conv_11 = a_vals[l];
47558 LDKRouteHint a_conv_11_conv;
47559 a_conv_11_conv.inner = untag_ptr(a_conv_11);
47560 a_conv_11_conv.is_owned = ptr_is_owned(a_conv_11);
47561 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv_11_conv);
47562 a_conv_11_conv = RouteHint_clone(&a_conv_11_conv);
47563 a_constr.data[l] = a_conv_11_conv;
47566 LDKHints *ret_copy = MALLOC(sizeof(LDKHints), "LDKHints");
47567 *ret_copy = Hints_clear(a_constr);
47568 uint64_t ret_ref = tag_ptr(ret_copy, true);
47572 int64_t __attribute__((export_name("TS_Hints_hash"))) TS_Hints_hash(uint64_t o) {
47573 LDKHints* o_conv = (LDKHints*)untag_ptr(o);
47574 int64_t ret_conv = Hints_hash(o_conv);
47578 jboolean __attribute__((export_name("TS_Hints_eq"))) TS_Hints_eq(uint64_t a, uint64_t b) {
47579 LDKHints* a_conv = (LDKHints*)untag_ptr(a);
47580 LDKHints* b_conv = (LDKHints*)untag_ptr(b);
47581 jboolean ret_conv = Hints_eq(a_conv, b_conv);
47585 void __attribute__((export_name("TS_RouteHint_free"))) TS_RouteHint_free(uint64_t this_obj) {
47586 LDKRouteHint this_obj_conv;
47587 this_obj_conv.inner = untag_ptr(this_obj);
47588 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47589 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47590 RouteHint_free(this_obj_conv);
47593 uint64_tArray __attribute__((export_name("TS_RouteHint_get_a"))) TS_RouteHint_get_a(uint64_t this_ptr) {
47594 LDKRouteHint this_ptr_conv;
47595 this_ptr_conv.inner = untag_ptr(this_ptr);
47596 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47597 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47598 this_ptr_conv.is_owned = false;
47599 LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
47600 uint64_tArray ret_arr = NULL;
47601 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
47602 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
47603 for (size_t o = 0; o < ret_var.datalen; o++) {
47604 LDKRouteHintHop ret_conv_14_var = ret_var.data[o];
47605 uint64_t ret_conv_14_ref = 0;
47606 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
47607 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
47608 ret_arr_ptr[o] = ret_conv_14_ref;
47611 FREE(ret_var.data);
47615 void __attribute__((export_name("TS_RouteHint_set_a"))) TS_RouteHint_set_a(uint64_t this_ptr, uint64_tArray val) {
47616 LDKRouteHint this_ptr_conv;
47617 this_ptr_conv.inner = untag_ptr(this_ptr);
47618 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47620 this_ptr_conv.is_owned = false;
47621 LDKCVec_RouteHintHopZ val_constr;
47622 val_constr.datalen = val->arr_len;
47623 if (val_constr.datalen > 0)
47624 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
47626 val_constr.data = NULL;
47627 uint64_t* val_vals = val->elems;
47628 for (size_t o = 0; o < val_constr.datalen; o++) {
47629 uint64_t val_conv_14 = val_vals[o];
47630 LDKRouteHintHop val_conv_14_conv;
47631 val_conv_14_conv.inner = untag_ptr(val_conv_14);
47632 val_conv_14_conv.is_owned = ptr_is_owned(val_conv_14);
47633 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
47634 val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
47635 val_constr.data[o] = val_conv_14_conv;
47638 RouteHint_set_a(&this_ptr_conv, val_constr);
47641 uint64_t __attribute__((export_name("TS_RouteHint_new"))) TS_RouteHint_new(uint64_tArray a_arg) {
47642 LDKCVec_RouteHintHopZ a_arg_constr;
47643 a_arg_constr.datalen = a_arg->arr_len;
47644 if (a_arg_constr.datalen > 0)
47645 a_arg_constr.data = MALLOC(a_arg_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
47647 a_arg_constr.data = NULL;
47648 uint64_t* a_arg_vals = a_arg->elems;
47649 for (size_t o = 0; o < a_arg_constr.datalen; o++) {
47650 uint64_t a_arg_conv_14 = a_arg_vals[o];
47651 LDKRouteHintHop a_arg_conv_14_conv;
47652 a_arg_conv_14_conv.inner = untag_ptr(a_arg_conv_14);
47653 a_arg_conv_14_conv.is_owned = ptr_is_owned(a_arg_conv_14);
47654 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
47655 a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
47656 a_arg_constr.data[o] = a_arg_conv_14_conv;
47659 LDKRouteHint ret_var = RouteHint_new(a_arg_constr);
47660 uint64_t ret_ref = 0;
47661 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47662 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47666 static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
47667 LDKRouteHint ret_var = RouteHint_clone(arg);
47668 uint64_t ret_ref = 0;
47669 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47670 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47673 int64_t __attribute__((export_name("TS_RouteHint_clone_ptr"))) TS_RouteHint_clone_ptr(uint64_t arg) {
47674 LDKRouteHint arg_conv;
47675 arg_conv.inner = untag_ptr(arg);
47676 arg_conv.is_owned = ptr_is_owned(arg);
47677 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47678 arg_conv.is_owned = false;
47679 int64_t ret_conv = RouteHint_clone_ptr(&arg_conv);
47683 uint64_t __attribute__((export_name("TS_RouteHint_clone"))) TS_RouteHint_clone(uint64_t orig) {
47684 LDKRouteHint orig_conv;
47685 orig_conv.inner = untag_ptr(orig);
47686 orig_conv.is_owned = ptr_is_owned(orig);
47687 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47688 orig_conv.is_owned = false;
47689 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
47690 uint64_t ret_ref = 0;
47691 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47692 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47696 int64_t __attribute__((export_name("TS_RouteHint_hash"))) TS_RouteHint_hash(uint64_t o) {
47697 LDKRouteHint o_conv;
47698 o_conv.inner = untag_ptr(o);
47699 o_conv.is_owned = ptr_is_owned(o);
47700 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47701 o_conv.is_owned = false;
47702 int64_t ret_conv = RouteHint_hash(&o_conv);
47706 jboolean __attribute__((export_name("TS_RouteHint_eq"))) TS_RouteHint_eq(uint64_t a, uint64_t b) {
47707 LDKRouteHint a_conv;
47708 a_conv.inner = untag_ptr(a);
47709 a_conv.is_owned = ptr_is_owned(a);
47710 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47711 a_conv.is_owned = false;
47712 LDKRouteHint b_conv;
47713 b_conv.inner = untag_ptr(b);
47714 b_conv.is_owned = ptr_is_owned(b);
47715 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47716 b_conv.is_owned = false;
47717 jboolean ret_conv = RouteHint_eq(&a_conv, &b_conv);
47721 int8_tArray __attribute__((export_name("TS_RouteHint_write"))) TS_RouteHint_write(uint64_t obj) {
47722 LDKRouteHint obj_conv;
47723 obj_conv.inner = untag_ptr(obj);
47724 obj_conv.is_owned = ptr_is_owned(obj);
47725 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47726 obj_conv.is_owned = false;
47727 LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
47728 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47729 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47730 CVec_u8Z_free(ret_var);
47734 uint64_t __attribute__((export_name("TS_RouteHint_read"))) TS_RouteHint_read(int8_tArray ser) {
47735 LDKu8slice ser_ref;
47736 ser_ref.datalen = ser->arr_len;
47737 ser_ref.data = ser->elems;
47738 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
47739 *ret_conv = RouteHint_read(ser_ref);
47741 return tag_ptr(ret_conv, true);
47744 void __attribute__((export_name("TS_RouteHintHop_free"))) TS_RouteHintHop_free(uint64_t this_obj) {
47745 LDKRouteHintHop this_obj_conv;
47746 this_obj_conv.inner = untag_ptr(this_obj);
47747 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47748 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47749 RouteHintHop_free(this_obj_conv);
47752 int8_tArray __attribute__((export_name("TS_RouteHintHop_get_src_node_id"))) TS_RouteHintHop_get_src_node_id(uint64_t this_ptr) {
47753 LDKRouteHintHop this_ptr_conv;
47754 this_ptr_conv.inner = untag_ptr(this_ptr);
47755 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47756 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47757 this_ptr_conv.is_owned = false;
47758 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47759 memcpy(ret_arr->elems, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
47763 void __attribute__((export_name("TS_RouteHintHop_set_src_node_id"))) TS_RouteHintHop_set_src_node_id(uint64_t this_ptr, int8_tArray val) {
47764 LDKRouteHintHop this_ptr_conv;
47765 this_ptr_conv.inner = untag_ptr(this_ptr);
47766 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47767 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47768 this_ptr_conv.is_owned = false;
47769 LDKPublicKey val_ref;
47770 CHECK(val->arr_len == 33);
47771 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47772 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
47775 int64_t __attribute__((export_name("TS_RouteHintHop_get_short_channel_id"))) TS_RouteHintHop_get_short_channel_id(uint64_t this_ptr) {
47776 LDKRouteHintHop this_ptr_conv;
47777 this_ptr_conv.inner = untag_ptr(this_ptr);
47778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47780 this_ptr_conv.is_owned = false;
47781 int64_t ret_conv = RouteHintHop_get_short_channel_id(&this_ptr_conv);
47785 void __attribute__((export_name("TS_RouteHintHop_set_short_channel_id"))) TS_RouteHintHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
47786 LDKRouteHintHop this_ptr_conv;
47787 this_ptr_conv.inner = untag_ptr(this_ptr);
47788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47790 this_ptr_conv.is_owned = false;
47791 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
47794 uint64_t __attribute__((export_name("TS_RouteHintHop_get_fees"))) TS_RouteHintHop_get_fees(uint64_t this_ptr) {
47795 LDKRouteHintHop this_ptr_conv;
47796 this_ptr_conv.inner = untag_ptr(this_ptr);
47797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47799 this_ptr_conv.is_owned = false;
47800 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
47801 uint64_t ret_ref = 0;
47802 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47803 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47807 void __attribute__((export_name("TS_RouteHintHop_set_fees"))) TS_RouteHintHop_set_fees(uint64_t this_ptr, uint64_t val) {
47808 LDKRouteHintHop this_ptr_conv;
47809 this_ptr_conv.inner = untag_ptr(this_ptr);
47810 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47812 this_ptr_conv.is_owned = false;
47813 LDKRoutingFees val_conv;
47814 val_conv.inner = untag_ptr(val);
47815 val_conv.is_owned = ptr_is_owned(val);
47816 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47817 val_conv = RoutingFees_clone(&val_conv);
47818 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
47821 int16_t __attribute__((export_name("TS_RouteHintHop_get_cltv_expiry_delta"))) TS_RouteHintHop_get_cltv_expiry_delta(uint64_t this_ptr) {
47822 LDKRouteHintHop this_ptr_conv;
47823 this_ptr_conv.inner = untag_ptr(this_ptr);
47824 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47826 this_ptr_conv.is_owned = false;
47827 int16_t ret_conv = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
47831 void __attribute__((export_name("TS_RouteHintHop_set_cltv_expiry_delta"))) TS_RouteHintHop_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
47832 LDKRouteHintHop this_ptr_conv;
47833 this_ptr_conv.inner = untag_ptr(this_ptr);
47834 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47835 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47836 this_ptr_conv.is_owned = false;
47837 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
47840 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_minimum_msat"))) TS_RouteHintHop_get_htlc_minimum_msat(uint64_t this_ptr) {
47841 LDKRouteHintHop this_ptr_conv;
47842 this_ptr_conv.inner = untag_ptr(this_ptr);
47843 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47844 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47845 this_ptr_conv.is_owned = false;
47846 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47847 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
47848 uint64_t ret_ref = tag_ptr(ret_copy, true);
47852 void __attribute__((export_name("TS_RouteHintHop_set_htlc_minimum_msat"))) TS_RouteHintHop_set_htlc_minimum_msat(uint64_t this_ptr, uint64_t val) {
47853 LDKRouteHintHop this_ptr_conv;
47854 this_ptr_conv.inner = untag_ptr(this_ptr);
47855 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47857 this_ptr_conv.is_owned = false;
47858 void* val_ptr = untag_ptr(val);
47859 CHECK_ACCESS(val_ptr);
47860 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
47861 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
47862 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
47865 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_maximum_msat"))) TS_RouteHintHop_get_htlc_maximum_msat(uint64_t this_ptr) {
47866 LDKRouteHintHop this_ptr_conv;
47867 this_ptr_conv.inner = untag_ptr(this_ptr);
47868 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47869 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47870 this_ptr_conv.is_owned = false;
47871 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
47872 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
47873 uint64_t ret_ref = tag_ptr(ret_copy, true);
47877 void __attribute__((export_name("TS_RouteHintHop_set_htlc_maximum_msat"))) TS_RouteHintHop_set_htlc_maximum_msat(uint64_t this_ptr, uint64_t val) {
47878 LDKRouteHintHop this_ptr_conv;
47879 this_ptr_conv.inner = untag_ptr(this_ptr);
47880 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47881 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47882 this_ptr_conv.is_owned = false;
47883 void* val_ptr = untag_ptr(val);
47884 CHECK_ACCESS(val_ptr);
47885 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
47886 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
47887 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
47890 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) {
47891 LDKPublicKey src_node_id_arg_ref;
47892 CHECK(src_node_id_arg->arr_len == 33);
47893 memcpy(src_node_id_arg_ref.compressed_form, src_node_id_arg->elems, 33); FREE(src_node_id_arg);
47894 LDKRoutingFees fees_arg_conv;
47895 fees_arg_conv.inner = untag_ptr(fees_arg);
47896 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
47897 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
47898 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
47899 void* htlc_minimum_msat_arg_ptr = untag_ptr(htlc_minimum_msat_arg);
47900 CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
47901 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_minimum_msat_arg_ptr);
47902 htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_minimum_msat_arg));
47903 void* htlc_maximum_msat_arg_ptr = untag_ptr(htlc_maximum_msat_arg);
47904 CHECK_ACCESS(htlc_maximum_msat_arg_ptr);
47905 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_maximum_msat_arg_ptr);
47906 htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_maximum_msat_arg));
47907 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);
47908 uint64_t ret_ref = 0;
47909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47914 static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
47915 LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
47916 uint64_t ret_ref = 0;
47917 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47918 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47921 int64_t __attribute__((export_name("TS_RouteHintHop_clone_ptr"))) TS_RouteHintHop_clone_ptr(uint64_t arg) {
47922 LDKRouteHintHop arg_conv;
47923 arg_conv.inner = untag_ptr(arg);
47924 arg_conv.is_owned = ptr_is_owned(arg);
47925 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47926 arg_conv.is_owned = false;
47927 int64_t ret_conv = RouteHintHop_clone_ptr(&arg_conv);
47931 uint64_t __attribute__((export_name("TS_RouteHintHop_clone"))) TS_RouteHintHop_clone(uint64_t orig) {
47932 LDKRouteHintHop orig_conv;
47933 orig_conv.inner = untag_ptr(orig);
47934 orig_conv.is_owned = ptr_is_owned(orig);
47935 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47936 orig_conv.is_owned = false;
47937 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
47938 uint64_t ret_ref = 0;
47939 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47940 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47944 int64_t __attribute__((export_name("TS_RouteHintHop_hash"))) TS_RouteHintHop_hash(uint64_t o) {
47945 LDKRouteHintHop o_conv;
47946 o_conv.inner = untag_ptr(o);
47947 o_conv.is_owned = ptr_is_owned(o);
47948 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47949 o_conv.is_owned = false;
47950 int64_t ret_conv = RouteHintHop_hash(&o_conv);
47954 jboolean __attribute__((export_name("TS_RouteHintHop_eq"))) TS_RouteHintHop_eq(uint64_t a, uint64_t b) {
47955 LDKRouteHintHop a_conv;
47956 a_conv.inner = untag_ptr(a);
47957 a_conv.is_owned = ptr_is_owned(a);
47958 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47959 a_conv.is_owned = false;
47960 LDKRouteHintHop b_conv;
47961 b_conv.inner = untag_ptr(b);
47962 b_conv.is_owned = ptr_is_owned(b);
47963 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47964 b_conv.is_owned = false;
47965 jboolean ret_conv = RouteHintHop_eq(&a_conv, &b_conv);
47969 int8_tArray __attribute__((export_name("TS_RouteHintHop_write"))) TS_RouteHintHop_write(uint64_t obj) {
47970 LDKRouteHintHop obj_conv;
47971 obj_conv.inner = untag_ptr(obj);
47972 obj_conv.is_owned = ptr_is_owned(obj);
47973 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47974 obj_conv.is_owned = false;
47975 LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
47976 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47977 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47978 CVec_u8Z_free(ret_var);
47982 uint64_t __attribute__((export_name("TS_RouteHintHop_read"))) TS_RouteHintHop_read(int8_tArray ser) {
47983 LDKu8slice ser_ref;
47984 ser_ref.datalen = ser->arr_len;
47985 ser_ref.data = ser->elems;
47986 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
47987 *ret_conv = RouteHintHop_read(ser_ref);
47989 return tag_ptr(ret_conv, true);
47992 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) {
47993 LDKPublicKey our_node_pubkey_ref;
47994 CHECK(our_node_pubkey->arr_len == 33);
47995 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
47996 LDKRouteParameters route_params_conv;
47997 route_params_conv.inner = untag_ptr(route_params);
47998 route_params_conv.is_owned = ptr_is_owned(route_params);
47999 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
48000 route_params_conv.is_owned = false;
48001 LDKNetworkGraph network_graph_conv;
48002 network_graph_conv.inner = untag_ptr(network_graph);
48003 network_graph_conv.is_owned = ptr_is_owned(network_graph);
48004 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
48005 network_graph_conv.is_owned = false;
48006 LDKCVec_ChannelDetailsZ first_hops_constr;
48007 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
48008 if (first_hops != 0) {
48009 first_hops_constr.datalen = first_hops->arr_len;
48010 if (first_hops_constr.datalen > 0)
48011 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
48013 first_hops_constr.data = NULL;
48014 uint64_t* first_hops_vals = first_hops->elems;
48015 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
48016 uint64_t first_hops_conv_16 = first_hops_vals[q];
48017 LDKChannelDetails first_hops_conv_16_conv;
48018 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
48019 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
48020 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
48021 first_hops_conv_16_conv.is_owned = false;
48022 first_hops_constr.data[q] = first_hops_conv_16_conv;
48025 first_hops_ptr = &first_hops_constr;
48027 void* logger_ptr = untag_ptr(logger);
48028 CHECK_ACCESS(logger_ptr);
48029 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48030 if (logger_conv.free == LDKLogger_JCalls_free) {
48031 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48032 LDKLogger_JCalls_cloned(&logger_conv);
48034 void* scorer_ptr = untag_ptr(scorer);
48035 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
48036 LDKScore* scorer_conv = (LDKScore*)scorer_ptr;
48037 uint8_t random_seed_bytes_arr[32];
48038 CHECK(random_seed_bytes->arr_len == 32);
48039 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
48040 uint8_t (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
48041 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
48042 *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);
48043 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
48044 return tag_ptr(ret_conv, true);
48047 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) {
48048 LDKPublicKey our_node_pubkey_ref;
48049 CHECK(our_node_pubkey->arr_len == 33);
48050 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
48051 LDKCVec_PublicKeyZ hops_constr;
48052 hops_constr.datalen = hops->arr_len;
48053 if (hops_constr.datalen > 0)
48054 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
48056 hops_constr.data = NULL;
48057 int8_tArray* hops_vals = (void*) hops->elems;
48058 for (size_t m = 0; m < hops_constr.datalen; m++) {
48059 int8_tArray hops_conv_12 = hops_vals[m];
48060 LDKPublicKey hops_conv_12_ref;
48061 CHECK(hops_conv_12->arr_len == 33);
48062 memcpy(hops_conv_12_ref.compressed_form, hops_conv_12->elems, 33); FREE(hops_conv_12);
48063 hops_constr.data[m] = hops_conv_12_ref;
48066 LDKRouteParameters route_params_conv;
48067 route_params_conv.inner = untag_ptr(route_params);
48068 route_params_conv.is_owned = ptr_is_owned(route_params);
48069 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
48070 route_params_conv.is_owned = false;
48071 LDKNetworkGraph network_graph_conv;
48072 network_graph_conv.inner = untag_ptr(network_graph);
48073 network_graph_conv.is_owned = ptr_is_owned(network_graph);
48074 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
48075 network_graph_conv.is_owned = false;
48076 void* logger_ptr = untag_ptr(logger);
48077 CHECK_ACCESS(logger_ptr);
48078 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48079 if (logger_conv.free == LDKLogger_JCalls_free) {
48080 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48081 LDKLogger_JCalls_cloned(&logger_conv);
48083 uint8_t random_seed_bytes_arr[32];
48084 CHECK(random_seed_bytes->arr_len == 32);
48085 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
48086 uint8_t (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
48087 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
48088 *ret_conv = build_route_from_hops(our_node_pubkey_ref, hops_constr, &route_params_conv, &network_graph_conv, logger_conv, random_seed_bytes_ref);
48089 return tag_ptr(ret_conv, true);
48092 void __attribute__((export_name("TS_Score_free"))) TS_Score_free(uint64_t this_ptr) {
48093 if (!ptr_is_owned(this_ptr)) return;
48094 void* this_ptr_ptr = untag_ptr(this_ptr);
48095 CHECK_ACCESS(this_ptr_ptr);
48096 LDKScore this_ptr_conv = *(LDKScore*)(this_ptr_ptr);
48097 FREE(untag_ptr(this_ptr));
48098 Score_free(this_ptr_conv);
48101 void __attribute__((export_name("TS_LockableScore_free"))) TS_LockableScore_free(uint64_t this_ptr) {
48102 if (!ptr_is_owned(this_ptr)) return;
48103 void* this_ptr_ptr = untag_ptr(this_ptr);
48104 CHECK_ACCESS(this_ptr_ptr);
48105 LDKLockableScore this_ptr_conv = *(LDKLockableScore*)(this_ptr_ptr);
48106 FREE(untag_ptr(this_ptr));
48107 LockableScore_free(this_ptr_conv);
48110 void __attribute__((export_name("TS_WriteableScore_free"))) TS_WriteableScore_free(uint64_t this_ptr) {
48111 if (!ptr_is_owned(this_ptr)) return;
48112 void* this_ptr_ptr = untag_ptr(this_ptr);
48113 CHECK_ACCESS(this_ptr_ptr);
48114 LDKWriteableScore this_ptr_conv = *(LDKWriteableScore*)(this_ptr_ptr);
48115 FREE(untag_ptr(this_ptr));
48116 WriteableScore_free(this_ptr_conv);
48119 void __attribute__((export_name("TS_MultiThreadedLockableScore_free"))) TS_MultiThreadedLockableScore_free(uint64_t this_obj) {
48120 LDKMultiThreadedLockableScore this_obj_conv;
48121 this_obj_conv.inner = untag_ptr(this_obj);
48122 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48123 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48124 MultiThreadedLockableScore_free(this_obj_conv);
48127 void __attribute__((export_name("TS_MultiThreadedScoreLock_free"))) TS_MultiThreadedScoreLock_free(uint64_t this_obj) {
48128 LDKMultiThreadedScoreLock this_obj_conv;
48129 this_obj_conv.inner = untag_ptr(this_obj);
48130 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48132 MultiThreadedScoreLock_free(this_obj_conv);
48135 uint64_t __attribute__((export_name("TS_MultiThreadedScoreLock_as_Score"))) TS_MultiThreadedScoreLock_as_Score(uint64_t this_arg) {
48136 LDKMultiThreadedScoreLock this_arg_conv;
48137 this_arg_conv.inner = untag_ptr(this_arg);
48138 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48140 this_arg_conv.is_owned = false;
48141 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
48142 *ret_ret = MultiThreadedScoreLock_as_Score(&this_arg_conv);
48143 return tag_ptr(ret_ret, true);
48146 int8_tArray __attribute__((export_name("TS_MultiThreadedScoreLock_write"))) TS_MultiThreadedScoreLock_write(uint64_t obj) {
48147 LDKMultiThreadedScoreLock obj_conv;
48148 obj_conv.inner = untag_ptr(obj);
48149 obj_conv.is_owned = ptr_is_owned(obj);
48150 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48151 obj_conv.is_owned = false;
48152 LDKCVec_u8Z ret_var = MultiThreadedScoreLock_write(&obj_conv);
48153 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48154 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48155 CVec_u8Z_free(ret_var);
48159 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_LockableScore"))) TS_MultiThreadedLockableScore_as_LockableScore(uint64_t this_arg) {
48160 LDKMultiThreadedLockableScore this_arg_conv;
48161 this_arg_conv.inner = untag_ptr(this_arg);
48162 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48164 this_arg_conv.is_owned = false;
48165 LDKLockableScore* ret_ret = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
48166 *ret_ret = MultiThreadedLockableScore_as_LockableScore(&this_arg_conv);
48167 return tag_ptr(ret_ret, true);
48170 int8_tArray __attribute__((export_name("TS_MultiThreadedLockableScore_write"))) TS_MultiThreadedLockableScore_write(uint64_t obj) {
48171 LDKMultiThreadedLockableScore obj_conv;
48172 obj_conv.inner = untag_ptr(obj);
48173 obj_conv.is_owned = ptr_is_owned(obj);
48174 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48175 obj_conv.is_owned = false;
48176 LDKCVec_u8Z ret_var = MultiThreadedLockableScore_write(&obj_conv);
48177 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48178 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48179 CVec_u8Z_free(ret_var);
48183 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_WriteableScore"))) TS_MultiThreadedLockableScore_as_WriteableScore(uint64_t this_arg) {
48184 LDKMultiThreadedLockableScore this_arg_conv;
48185 this_arg_conv.inner = untag_ptr(this_arg);
48186 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48188 this_arg_conv.is_owned = false;
48189 LDKWriteableScore* ret_ret = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
48190 *ret_ret = MultiThreadedLockableScore_as_WriteableScore(&this_arg_conv);
48191 return tag_ptr(ret_ret, true);
48194 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_new"))) TS_MultiThreadedLockableScore_new(uint64_t score) {
48195 void* score_ptr = untag_ptr(score);
48196 CHECK_ACCESS(score_ptr);
48197 LDKScore score_conv = *(LDKScore*)(score_ptr);
48198 if (score_conv.free == LDKScore_JCalls_free) {
48199 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48200 LDKScore_JCalls_cloned(&score_conv);
48202 LDKMultiThreadedLockableScore ret_var = MultiThreadedLockableScore_new(score_conv);
48203 uint64_t ret_ref = 0;
48204 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48205 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48209 void __attribute__((export_name("TS_ChannelUsage_free"))) TS_ChannelUsage_free(uint64_t this_obj) {
48210 LDKChannelUsage this_obj_conv;
48211 this_obj_conv.inner = untag_ptr(this_obj);
48212 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48214 ChannelUsage_free(this_obj_conv);
48217 int64_t __attribute__((export_name("TS_ChannelUsage_get_amount_msat"))) TS_ChannelUsage_get_amount_msat(uint64_t this_ptr) {
48218 LDKChannelUsage this_ptr_conv;
48219 this_ptr_conv.inner = untag_ptr(this_ptr);
48220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48222 this_ptr_conv.is_owned = false;
48223 int64_t ret_conv = ChannelUsage_get_amount_msat(&this_ptr_conv);
48227 void __attribute__((export_name("TS_ChannelUsage_set_amount_msat"))) TS_ChannelUsage_set_amount_msat(uint64_t this_ptr, int64_t val) {
48228 LDKChannelUsage this_ptr_conv;
48229 this_ptr_conv.inner = untag_ptr(this_ptr);
48230 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48231 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48232 this_ptr_conv.is_owned = false;
48233 ChannelUsage_set_amount_msat(&this_ptr_conv, val);
48236 int64_t __attribute__((export_name("TS_ChannelUsage_get_inflight_htlc_msat"))) TS_ChannelUsage_get_inflight_htlc_msat(uint64_t this_ptr) {
48237 LDKChannelUsage this_ptr_conv;
48238 this_ptr_conv.inner = untag_ptr(this_ptr);
48239 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48241 this_ptr_conv.is_owned = false;
48242 int64_t ret_conv = ChannelUsage_get_inflight_htlc_msat(&this_ptr_conv);
48246 void __attribute__((export_name("TS_ChannelUsage_set_inflight_htlc_msat"))) TS_ChannelUsage_set_inflight_htlc_msat(uint64_t this_ptr, int64_t val) {
48247 LDKChannelUsage this_ptr_conv;
48248 this_ptr_conv.inner = untag_ptr(this_ptr);
48249 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48251 this_ptr_conv.is_owned = false;
48252 ChannelUsage_set_inflight_htlc_msat(&this_ptr_conv, val);
48255 uint64_t __attribute__((export_name("TS_ChannelUsage_get_effective_capacity"))) TS_ChannelUsage_get_effective_capacity(uint64_t this_ptr) {
48256 LDKChannelUsage this_ptr_conv;
48257 this_ptr_conv.inner = untag_ptr(this_ptr);
48258 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48260 this_ptr_conv.is_owned = false;
48261 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
48262 *ret_copy = ChannelUsage_get_effective_capacity(&this_ptr_conv);
48263 uint64_t ret_ref = tag_ptr(ret_copy, true);
48267 void __attribute__((export_name("TS_ChannelUsage_set_effective_capacity"))) TS_ChannelUsage_set_effective_capacity(uint64_t this_ptr, uint64_t val) {
48268 LDKChannelUsage this_ptr_conv;
48269 this_ptr_conv.inner = untag_ptr(this_ptr);
48270 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48272 this_ptr_conv.is_owned = false;
48273 void* val_ptr = untag_ptr(val);
48274 CHECK_ACCESS(val_ptr);
48275 LDKEffectiveCapacity val_conv = *(LDKEffectiveCapacity*)(val_ptr);
48276 val_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(val));
48277 ChannelUsage_set_effective_capacity(&this_ptr_conv, val_conv);
48280 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) {
48281 void* effective_capacity_arg_ptr = untag_ptr(effective_capacity_arg);
48282 CHECK_ACCESS(effective_capacity_arg_ptr);
48283 LDKEffectiveCapacity effective_capacity_arg_conv = *(LDKEffectiveCapacity*)(effective_capacity_arg_ptr);
48284 effective_capacity_arg_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(effective_capacity_arg));
48285 LDKChannelUsage ret_var = ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg_conv);
48286 uint64_t ret_ref = 0;
48287 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48288 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48292 static inline uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg) {
48293 LDKChannelUsage ret_var = ChannelUsage_clone(arg);
48294 uint64_t ret_ref = 0;
48295 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48296 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48299 int64_t __attribute__((export_name("TS_ChannelUsage_clone_ptr"))) TS_ChannelUsage_clone_ptr(uint64_t arg) {
48300 LDKChannelUsage arg_conv;
48301 arg_conv.inner = untag_ptr(arg);
48302 arg_conv.is_owned = ptr_is_owned(arg);
48303 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48304 arg_conv.is_owned = false;
48305 int64_t ret_conv = ChannelUsage_clone_ptr(&arg_conv);
48309 uint64_t __attribute__((export_name("TS_ChannelUsage_clone"))) TS_ChannelUsage_clone(uint64_t orig) {
48310 LDKChannelUsage orig_conv;
48311 orig_conv.inner = untag_ptr(orig);
48312 orig_conv.is_owned = ptr_is_owned(orig);
48313 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48314 orig_conv.is_owned = false;
48315 LDKChannelUsage ret_var = ChannelUsage_clone(&orig_conv);
48316 uint64_t ret_ref = 0;
48317 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48318 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48322 void __attribute__((export_name("TS_FixedPenaltyScorer_free"))) TS_FixedPenaltyScorer_free(uint64_t this_obj) {
48323 LDKFixedPenaltyScorer this_obj_conv;
48324 this_obj_conv.inner = untag_ptr(this_obj);
48325 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48326 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48327 FixedPenaltyScorer_free(this_obj_conv);
48330 static inline uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg) {
48331 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(arg);
48332 uint64_t ret_ref = 0;
48333 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48334 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48337 int64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone_ptr"))) TS_FixedPenaltyScorer_clone_ptr(uint64_t arg) {
48338 LDKFixedPenaltyScorer arg_conv;
48339 arg_conv.inner = untag_ptr(arg);
48340 arg_conv.is_owned = ptr_is_owned(arg);
48341 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48342 arg_conv.is_owned = false;
48343 int64_t ret_conv = FixedPenaltyScorer_clone_ptr(&arg_conv);
48347 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone"))) TS_FixedPenaltyScorer_clone(uint64_t orig) {
48348 LDKFixedPenaltyScorer orig_conv;
48349 orig_conv.inner = untag_ptr(orig);
48350 orig_conv.is_owned = ptr_is_owned(orig);
48351 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48352 orig_conv.is_owned = false;
48353 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(&orig_conv);
48354 uint64_t ret_ref = 0;
48355 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48356 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48360 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_with_penalty"))) TS_FixedPenaltyScorer_with_penalty(int64_t penalty_msat) {
48361 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_with_penalty(penalty_msat);
48362 uint64_t ret_ref = 0;
48363 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48364 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48368 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_as_Score"))) TS_FixedPenaltyScorer_as_Score(uint64_t this_arg) {
48369 LDKFixedPenaltyScorer this_arg_conv;
48370 this_arg_conv.inner = untag_ptr(this_arg);
48371 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48372 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48373 this_arg_conv.is_owned = false;
48374 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
48375 *ret_ret = FixedPenaltyScorer_as_Score(&this_arg_conv);
48376 return tag_ptr(ret_ret, true);
48379 int8_tArray __attribute__((export_name("TS_FixedPenaltyScorer_write"))) TS_FixedPenaltyScorer_write(uint64_t obj) {
48380 LDKFixedPenaltyScorer obj_conv;
48381 obj_conv.inner = untag_ptr(obj);
48382 obj_conv.is_owned = ptr_is_owned(obj);
48383 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48384 obj_conv.is_owned = false;
48385 LDKCVec_u8Z ret_var = FixedPenaltyScorer_write(&obj_conv);
48386 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48387 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48388 CVec_u8Z_free(ret_var);
48392 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_read"))) TS_FixedPenaltyScorer_read(int8_tArray ser, int64_t arg) {
48393 LDKu8slice ser_ref;
48394 ser_ref.datalen = ser->arr_len;
48395 ser_ref.data = ser->elems;
48396 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
48397 *ret_conv = FixedPenaltyScorer_read(ser_ref, arg);
48399 return tag_ptr(ret_conv, true);
48402 void __attribute__((export_name("TS_ProbabilisticScorer_free"))) TS_ProbabilisticScorer_free(uint64_t this_obj) {
48403 LDKProbabilisticScorer this_obj_conv;
48404 this_obj_conv.inner = untag_ptr(this_obj);
48405 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48406 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48407 ProbabilisticScorer_free(this_obj_conv);
48410 void __attribute__((export_name("TS_ProbabilisticScoringParameters_free"))) TS_ProbabilisticScoringParameters_free(uint64_t this_obj) {
48411 LDKProbabilisticScoringParameters this_obj_conv;
48412 this_obj_conv.inner = untag_ptr(this_obj);
48413 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48414 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48415 ProbabilisticScoringParameters_free(this_obj_conv);
48418 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_base_penalty_msat"))) TS_ProbabilisticScoringParameters_get_base_penalty_msat(uint64_t this_ptr) {
48419 LDKProbabilisticScoringParameters this_ptr_conv;
48420 this_ptr_conv.inner = untag_ptr(this_ptr);
48421 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48423 this_ptr_conv.is_owned = false;
48424 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_msat(&this_ptr_conv);
48428 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_base_penalty_msat"))) TS_ProbabilisticScoringParameters_set_base_penalty_msat(uint64_t this_ptr, int64_t val) {
48429 LDKProbabilisticScoringParameters this_ptr_conv;
48430 this_ptr_conv.inner = untag_ptr(this_ptr);
48431 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48433 this_ptr_conv.is_owned = false;
48434 ProbabilisticScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
48437 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) {
48438 LDKProbabilisticScoringParameters this_ptr_conv;
48439 this_ptr_conv.inner = untag_ptr(this_ptr);
48440 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48441 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48442 this_ptr_conv.is_owned = false;
48443 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(&this_ptr_conv);
48447 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) {
48448 LDKProbabilisticScoringParameters this_ptr_conv;
48449 this_ptr_conv.inner = untag_ptr(this_ptr);
48450 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48452 this_ptr_conv.is_owned = false;
48453 ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(&this_ptr_conv, val);
48456 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(uint64_t this_ptr) {
48457 LDKProbabilisticScoringParameters this_ptr_conv;
48458 this_ptr_conv.inner = untag_ptr(this_ptr);
48459 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48460 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48461 this_ptr_conv.is_owned = false;
48462 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(&this_ptr_conv);
48466 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) {
48467 LDKProbabilisticScoringParameters this_ptr_conv;
48468 this_ptr_conv.inner = untag_ptr(this_ptr);
48469 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48471 this_ptr_conv.is_owned = false;
48472 ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
48475 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life"))) TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(uint64_t this_ptr) {
48476 LDKProbabilisticScoringParameters this_ptr_conv;
48477 this_ptr_conv.inner = untag_ptr(this_ptr);
48478 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48480 this_ptr_conv.is_owned = false;
48481 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_offset_half_life(&this_ptr_conv);
48485 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) {
48486 LDKProbabilisticScoringParameters this_ptr_conv;
48487 this_ptr_conv.inner = untag_ptr(this_ptr);
48488 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48490 this_ptr_conv.is_owned = false;
48491 ProbabilisticScoringParameters_set_liquidity_offset_half_life(&this_ptr_conv, val);
48494 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) {
48495 LDKProbabilisticScoringParameters this_ptr_conv;
48496 this_ptr_conv.inner = untag_ptr(this_ptr);
48497 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48499 this_ptr_conv.is_owned = false;
48500 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
48504 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) {
48505 LDKProbabilisticScoringParameters this_ptr_conv;
48506 this_ptr_conv.inner = untag_ptr(this_ptr);
48507 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48508 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48509 this_ptr_conv.is_owned = false;
48510 ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
48513 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) {
48514 LDKProbabilisticScoringParameters this_ptr_conv;
48515 this_ptr_conv.inner = untag_ptr(this_ptr);
48516 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48518 this_ptr_conv.is_owned = false;
48519 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv);
48523 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) {
48524 LDKProbabilisticScoringParameters this_ptr_conv;
48525 this_ptr_conv.inner = untag_ptr(this_ptr);
48526 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48528 this_ptr_conv.is_owned = false;
48529 ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
48532 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) {
48533 LDKProbabilisticScoringParameters this_ptr_conv;
48534 this_ptr_conv.inner = untag_ptr(this_ptr);
48535 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48537 this_ptr_conv.is_owned = false;
48538 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
48542 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) {
48543 LDKProbabilisticScoringParameters this_ptr_conv;
48544 this_ptr_conv.inner = untag_ptr(this_ptr);
48545 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48547 this_ptr_conv.is_owned = false;
48548 ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
48551 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) {
48552 LDKProbabilisticScoringParameters this_ptr_conv;
48553 this_ptr_conv.inner = untag_ptr(this_ptr);
48554 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48556 this_ptr_conv.is_owned = false;
48557 int64_t ret_conv = ProbabilisticScoringParameters_get_historical_no_updates_half_life(&this_ptr_conv);
48561 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) {
48562 LDKProbabilisticScoringParameters this_ptr_conv;
48563 this_ptr_conv.inner = untag_ptr(this_ptr);
48564 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48566 this_ptr_conv.is_owned = false;
48567 ProbabilisticScoringParameters_set_historical_no_updates_half_life(&this_ptr_conv, val);
48570 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat"))) TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(uint64_t this_ptr) {
48571 LDKProbabilisticScoringParameters this_ptr_conv;
48572 this_ptr_conv.inner = untag_ptr(this_ptr);
48573 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48575 this_ptr_conv.is_owned = false;
48576 int64_t ret_conv = ProbabilisticScoringParameters_get_anti_probing_penalty_msat(&this_ptr_conv);
48580 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) {
48581 LDKProbabilisticScoringParameters this_ptr_conv;
48582 this_ptr_conv.inner = untag_ptr(this_ptr);
48583 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48585 this_ptr_conv.is_owned = false;
48586 ProbabilisticScoringParameters_set_anti_probing_penalty_msat(&this_ptr_conv, val);
48589 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(uint64_t this_ptr) {
48590 LDKProbabilisticScoringParameters this_ptr_conv;
48591 this_ptr_conv.inner = untag_ptr(this_ptr);
48592 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48594 this_ptr_conv.is_owned = false;
48595 int64_t ret_conv = ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(&this_ptr_conv);
48599 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) {
48600 LDKProbabilisticScoringParameters this_ptr_conv;
48601 this_ptr_conv.inner = untag_ptr(this_ptr);
48602 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48604 this_ptr_conv.is_owned = false;
48605 ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(&this_ptr_conv, val);
48608 static inline uint64_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg) {
48609 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(arg);
48610 uint64_t ret_ref = 0;
48611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48612 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48615 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone_ptr"))) TS_ProbabilisticScoringParameters_clone_ptr(uint64_t arg) {
48616 LDKProbabilisticScoringParameters arg_conv;
48617 arg_conv.inner = untag_ptr(arg);
48618 arg_conv.is_owned = ptr_is_owned(arg);
48619 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48620 arg_conv.is_owned = false;
48621 int64_t ret_conv = ProbabilisticScoringParameters_clone_ptr(&arg_conv);
48625 uint64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone"))) TS_ProbabilisticScoringParameters_clone(uint64_t orig) {
48626 LDKProbabilisticScoringParameters orig_conv;
48627 orig_conv.inner = untag_ptr(orig);
48628 orig_conv.is_owned = ptr_is_owned(orig);
48629 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48630 orig_conv.is_owned = false;
48631 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(&orig_conv);
48632 uint64_t ret_ref = 0;
48633 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48634 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48638 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_new"))) TS_ProbabilisticScorer_new(uint64_t params, uint64_t network_graph, uint64_t logger) {
48639 LDKProbabilisticScoringParameters params_conv;
48640 params_conv.inner = untag_ptr(params);
48641 params_conv.is_owned = ptr_is_owned(params);
48642 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
48643 params_conv = ProbabilisticScoringParameters_clone(¶ms_conv);
48644 LDKNetworkGraph network_graph_conv;
48645 network_graph_conv.inner = untag_ptr(network_graph);
48646 network_graph_conv.is_owned = ptr_is_owned(network_graph);
48647 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
48648 network_graph_conv.is_owned = false;
48649 void* logger_ptr = untag_ptr(logger);
48650 CHECK_ACCESS(logger_ptr);
48651 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
48652 if (logger_conv.free == LDKLogger_JCalls_free) {
48653 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48654 LDKLogger_JCalls_cloned(&logger_conv);
48656 LDKProbabilisticScorer ret_var = ProbabilisticScorer_new(params_conv, &network_graph_conv, logger_conv);
48657 uint64_t ret_ref = 0;
48658 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48659 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48663 void __attribute__((export_name("TS_ProbabilisticScorer_debug_log_liquidity_stats"))) TS_ProbabilisticScorer_debug_log_liquidity_stats(uint64_t this_arg) {
48664 LDKProbabilisticScorer this_arg_conv;
48665 this_arg_conv.inner = untag_ptr(this_arg);
48666 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48668 this_arg_conv.is_owned = false;
48669 ProbabilisticScorer_debug_log_liquidity_stats(&this_arg_conv);
48672 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) {
48673 LDKProbabilisticScorer this_arg_conv;
48674 this_arg_conv.inner = untag_ptr(this_arg);
48675 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48677 this_arg_conv.is_owned = false;
48678 LDKNodeId target_conv;
48679 target_conv.inner = untag_ptr(target);
48680 target_conv.is_owned = ptr_is_owned(target);
48681 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
48682 target_conv.is_owned = false;
48683 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
48684 *ret_copy = ProbabilisticScorer_estimated_channel_liquidity_range(&this_arg_conv, scid, &target_conv);
48685 uint64_t ret_ref = tag_ptr(ret_copy, true);
48689 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) {
48690 LDKProbabilisticScorer this_arg_conv;
48691 this_arg_conv.inner = untag_ptr(this_arg);
48692 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48693 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48694 this_arg_conv.is_owned = false;
48695 LDKNodeId target_conv;
48696 target_conv.inner = untag_ptr(target);
48697 target_conv.is_owned = ptr_is_owned(target);
48698 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
48699 target_conv.is_owned = false;
48700 LDKCOption_C2Tuple_EightU16sEightU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_EightU16sEightU16sZZ), "LDKCOption_C2Tuple_EightU16sEightU16sZZ");
48701 *ret_copy = ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(&this_arg_conv, scid, &target_conv);
48702 uint64_t ret_ref = tag_ptr(ret_copy, true);
48706 void __attribute__((export_name("TS_ProbabilisticScorer_add_banned"))) TS_ProbabilisticScorer_add_banned(uint64_t this_arg, uint64_t node_id) {
48707 LDKProbabilisticScorer this_arg_conv;
48708 this_arg_conv.inner = untag_ptr(this_arg);
48709 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48711 this_arg_conv.is_owned = false;
48712 LDKNodeId node_id_conv;
48713 node_id_conv.inner = untag_ptr(node_id);
48714 node_id_conv.is_owned = ptr_is_owned(node_id);
48715 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48716 node_id_conv.is_owned = false;
48717 ProbabilisticScorer_add_banned(&this_arg_conv, &node_id_conv);
48720 void __attribute__((export_name("TS_ProbabilisticScorer_remove_banned"))) TS_ProbabilisticScorer_remove_banned(uint64_t this_arg, uint64_t node_id) {
48721 LDKProbabilisticScorer this_arg_conv;
48722 this_arg_conv.inner = untag_ptr(this_arg);
48723 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48724 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48725 this_arg_conv.is_owned = false;
48726 LDKNodeId node_id_conv;
48727 node_id_conv.inner = untag_ptr(node_id);
48728 node_id_conv.is_owned = ptr_is_owned(node_id);
48729 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48730 node_id_conv.is_owned = false;
48731 ProbabilisticScorer_remove_banned(&this_arg_conv, &node_id_conv);
48734 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) {
48735 LDKProbabilisticScorer this_arg_conv;
48736 this_arg_conv.inner = untag_ptr(this_arg);
48737 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48739 this_arg_conv.is_owned = false;
48740 LDKNodeId node_id_conv;
48741 node_id_conv.inner = untag_ptr(node_id);
48742 node_id_conv.is_owned = ptr_is_owned(node_id);
48743 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48744 node_id_conv.is_owned = false;
48745 ProbabilisticScorer_set_manual_penalty(&this_arg_conv, &node_id_conv, penalty);
48748 void __attribute__((export_name("TS_ProbabilisticScorer_remove_manual_penalty"))) TS_ProbabilisticScorer_remove_manual_penalty(uint64_t this_arg, uint64_t node_id) {
48749 LDKProbabilisticScorer this_arg_conv;
48750 this_arg_conv.inner = untag_ptr(this_arg);
48751 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48753 this_arg_conv.is_owned = false;
48754 LDKNodeId node_id_conv;
48755 node_id_conv.inner = untag_ptr(node_id);
48756 node_id_conv.is_owned = ptr_is_owned(node_id);
48757 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
48758 node_id_conv.is_owned = false;
48759 ProbabilisticScorer_remove_manual_penalty(&this_arg_conv, &node_id_conv);
48762 void __attribute__((export_name("TS_ProbabilisticScorer_clear_manual_penalties"))) TS_ProbabilisticScorer_clear_manual_penalties(uint64_t this_arg) {
48763 LDKProbabilisticScorer this_arg_conv;
48764 this_arg_conv.inner = untag_ptr(this_arg);
48765 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48767 this_arg_conv.is_owned = false;
48768 ProbabilisticScorer_clear_manual_penalties(&this_arg_conv);
48771 void __attribute__((export_name("TS_ProbabilisticScoringParameters_add_banned_from_list"))) TS_ProbabilisticScoringParameters_add_banned_from_list(uint64_t this_arg, uint64_tArray node_ids) {
48772 LDKProbabilisticScoringParameters this_arg_conv;
48773 this_arg_conv.inner = untag_ptr(this_arg);
48774 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48776 this_arg_conv.is_owned = false;
48777 LDKCVec_NodeIdZ node_ids_constr;
48778 node_ids_constr.datalen = node_ids->arr_len;
48779 if (node_ids_constr.datalen > 0)
48780 node_ids_constr.data = MALLOC(node_ids_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
48782 node_ids_constr.data = NULL;
48783 uint64_t* node_ids_vals = node_ids->elems;
48784 for (size_t i = 0; i < node_ids_constr.datalen; i++) {
48785 uint64_t node_ids_conv_8 = node_ids_vals[i];
48786 LDKNodeId node_ids_conv_8_conv;
48787 node_ids_conv_8_conv.inner = untag_ptr(node_ids_conv_8);
48788 node_ids_conv_8_conv.is_owned = ptr_is_owned(node_ids_conv_8);
48789 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_ids_conv_8_conv);
48790 node_ids_conv_8_conv = NodeId_clone(&node_ids_conv_8_conv);
48791 node_ids_constr.data[i] = node_ids_conv_8_conv;
48794 ProbabilisticScoringParameters_add_banned_from_list(&this_arg_conv, node_ids_constr);
48797 uint64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_default"))) TS_ProbabilisticScoringParameters_default() {
48798 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_default();
48799 uint64_t ret_ref = 0;
48800 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48801 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48805 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_as_Score"))) TS_ProbabilisticScorer_as_Score(uint64_t this_arg) {
48806 LDKProbabilisticScorer this_arg_conv;
48807 this_arg_conv.inner = untag_ptr(this_arg);
48808 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48810 this_arg_conv.is_owned = false;
48811 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
48812 *ret_ret = ProbabilisticScorer_as_Score(&this_arg_conv);
48813 return tag_ptr(ret_ret, true);
48816 int8_tArray __attribute__((export_name("TS_ProbabilisticScorer_write"))) TS_ProbabilisticScorer_write(uint64_t obj) {
48817 LDKProbabilisticScorer obj_conv;
48818 obj_conv.inner = untag_ptr(obj);
48819 obj_conv.is_owned = ptr_is_owned(obj);
48820 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48821 obj_conv.is_owned = false;
48822 LDKCVec_u8Z ret_var = ProbabilisticScorer_write(&obj_conv);
48823 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48824 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48825 CVec_u8Z_free(ret_var);
48829 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) {
48830 LDKu8slice ser_ref;
48831 ser_ref.datalen = ser->arr_len;
48832 ser_ref.data = ser->elems;
48833 LDKProbabilisticScoringParameters arg_a_conv;
48834 arg_a_conv.inner = untag_ptr(arg_a);
48835 arg_a_conv.is_owned = ptr_is_owned(arg_a);
48836 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_a_conv);
48837 arg_a_conv = ProbabilisticScoringParameters_clone(&arg_a_conv);
48838 LDKNetworkGraph arg_b_conv;
48839 arg_b_conv.inner = untag_ptr(arg_b);
48840 arg_b_conv.is_owned = ptr_is_owned(arg_b);
48841 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_b_conv);
48842 arg_b_conv.is_owned = false;
48843 void* arg_c_ptr = untag_ptr(arg_c);
48844 CHECK_ACCESS(arg_c_ptr);
48845 LDKLogger arg_c_conv = *(LDKLogger*)(arg_c_ptr);
48846 if (arg_c_conv.free == LDKLogger_JCalls_free) {
48847 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
48848 LDKLogger_JCalls_cloned(&arg_c_conv);
48850 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
48851 *ret_conv = ProbabilisticScorer_read(ser_ref, arg_a_conv, &arg_b_conv, arg_c_conv);
48853 return tag_ptr(ret_conv, true);
48856 void __attribute__((export_name("TS_OnionMessenger_free"))) TS_OnionMessenger_free(uint64_t this_obj) {
48857 LDKOnionMessenger this_obj_conv;
48858 this_obj_conv.inner = untag_ptr(this_obj);
48859 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48861 OnionMessenger_free(this_obj_conv);
48864 void __attribute__((export_name("TS_Destination_free"))) TS_Destination_free(uint64_t this_ptr) {
48865 if (!ptr_is_owned(this_ptr)) return;
48866 void* this_ptr_ptr = untag_ptr(this_ptr);
48867 CHECK_ACCESS(this_ptr_ptr);
48868 LDKDestination this_ptr_conv = *(LDKDestination*)(this_ptr_ptr);
48869 FREE(untag_ptr(this_ptr));
48870 Destination_free(this_ptr_conv);
48873 static inline uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg) {
48874 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48875 *ret_copy = Destination_clone(arg);
48876 uint64_t ret_ref = tag_ptr(ret_copy, true);
48879 int64_t __attribute__((export_name("TS_Destination_clone_ptr"))) TS_Destination_clone_ptr(uint64_t arg) {
48880 LDKDestination* arg_conv = (LDKDestination*)untag_ptr(arg);
48881 int64_t ret_conv = Destination_clone_ptr(arg_conv);
48885 uint64_t __attribute__((export_name("TS_Destination_clone"))) TS_Destination_clone(uint64_t orig) {
48886 LDKDestination* orig_conv = (LDKDestination*)untag_ptr(orig);
48887 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48888 *ret_copy = Destination_clone(orig_conv);
48889 uint64_t ret_ref = tag_ptr(ret_copy, true);
48893 uint64_t __attribute__((export_name("TS_Destination_node"))) TS_Destination_node(int8_tArray a) {
48894 LDKPublicKey a_ref;
48895 CHECK(a->arr_len == 33);
48896 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
48897 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48898 *ret_copy = Destination_node(a_ref);
48899 uint64_t ret_ref = tag_ptr(ret_copy, true);
48903 uint64_t __attribute__((export_name("TS_Destination_blinded_path"))) TS_Destination_blinded_path(uint64_t a) {
48904 LDKBlindedPath a_conv;
48905 a_conv.inner = untag_ptr(a);
48906 a_conv.is_owned = ptr_is_owned(a);
48907 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
48908 a_conv = BlindedPath_clone(&a_conv);
48909 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
48910 *ret_copy = Destination_blinded_path(a_conv);
48911 uint64_t ret_ref = tag_ptr(ret_copy, true);
48915 void __attribute__((export_name("TS_SendError_free"))) TS_SendError_free(uint64_t this_ptr) {
48916 if (!ptr_is_owned(this_ptr)) return;
48917 void* this_ptr_ptr = untag_ptr(this_ptr);
48918 CHECK_ACCESS(this_ptr_ptr);
48919 LDKSendError this_ptr_conv = *(LDKSendError*)(this_ptr_ptr);
48920 FREE(untag_ptr(this_ptr));
48921 SendError_free(this_ptr_conv);
48924 static inline uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg) {
48925 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48926 *ret_copy = SendError_clone(arg);
48927 uint64_t ret_ref = tag_ptr(ret_copy, true);
48930 int64_t __attribute__((export_name("TS_SendError_clone_ptr"))) TS_SendError_clone_ptr(uint64_t arg) {
48931 LDKSendError* arg_conv = (LDKSendError*)untag_ptr(arg);
48932 int64_t ret_conv = SendError_clone_ptr(arg_conv);
48936 uint64_t __attribute__((export_name("TS_SendError_clone"))) TS_SendError_clone(uint64_t orig) {
48937 LDKSendError* orig_conv = (LDKSendError*)untag_ptr(orig);
48938 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48939 *ret_copy = SendError_clone(orig_conv);
48940 uint64_t ret_ref = tag_ptr(ret_copy, true);
48944 uint64_t __attribute__((export_name("TS_SendError_secp256k1"))) TS_SendError_secp256k1(uint32_t a) {
48945 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
48946 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48947 *ret_copy = SendError_secp256k1(a_conv);
48948 uint64_t ret_ref = tag_ptr(ret_copy, true);
48952 uint64_t __attribute__((export_name("TS_SendError_too_big_packet"))) TS_SendError_too_big_packet() {
48953 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48954 *ret_copy = SendError_too_big_packet();
48955 uint64_t ret_ref = tag_ptr(ret_copy, true);
48959 uint64_t __attribute__((export_name("TS_SendError_too_few_blinded_hops"))) TS_SendError_too_few_blinded_hops() {
48960 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48961 *ret_copy = SendError_too_few_blinded_hops();
48962 uint64_t ret_ref = tag_ptr(ret_copy, true);
48966 uint64_t __attribute__((export_name("TS_SendError_invalid_first_hop"))) TS_SendError_invalid_first_hop() {
48967 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48968 *ret_copy = SendError_invalid_first_hop();
48969 uint64_t ret_ref = tag_ptr(ret_copy, true);
48973 uint64_t __attribute__((export_name("TS_SendError_invalid_message"))) TS_SendError_invalid_message() {
48974 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48975 *ret_copy = SendError_invalid_message();
48976 uint64_t ret_ref = tag_ptr(ret_copy, true);
48980 uint64_t __attribute__((export_name("TS_SendError_buffer_full"))) TS_SendError_buffer_full() {
48981 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48982 *ret_copy = SendError_buffer_full();
48983 uint64_t ret_ref = tag_ptr(ret_copy, true);
48987 uint64_t __attribute__((export_name("TS_SendError_get_node_id_failed"))) TS_SendError_get_node_id_failed() {
48988 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48989 *ret_copy = SendError_get_node_id_failed();
48990 uint64_t ret_ref = tag_ptr(ret_copy, true);
48994 uint64_t __attribute__((export_name("TS_SendError_blinded_path_advance_failed"))) TS_SendError_blinded_path_advance_failed() {
48995 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
48996 *ret_copy = SendError_blinded_path_advance_failed();
48997 uint64_t ret_ref = tag_ptr(ret_copy, true);
49001 jboolean __attribute__((export_name("TS_SendError_eq"))) TS_SendError_eq(uint64_t a, uint64_t b) {
49002 LDKSendError* a_conv = (LDKSendError*)untag_ptr(a);
49003 LDKSendError* b_conv = (LDKSendError*)untag_ptr(b);
49004 jboolean ret_conv = SendError_eq(a_conv, b_conv);
49008 void __attribute__((export_name("TS_CustomOnionMessageHandler_free"))) TS_CustomOnionMessageHandler_free(uint64_t this_ptr) {
49009 if (!ptr_is_owned(this_ptr)) return;
49010 void* this_ptr_ptr = untag_ptr(this_ptr);
49011 CHECK_ACCESS(this_ptr_ptr);
49012 LDKCustomOnionMessageHandler this_ptr_conv = *(LDKCustomOnionMessageHandler*)(this_ptr_ptr);
49013 FREE(untag_ptr(this_ptr));
49014 CustomOnionMessageHandler_free(this_ptr_conv);
49017 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) {
49018 void* entropy_source_ptr = untag_ptr(entropy_source);
49019 CHECK_ACCESS(entropy_source_ptr);
49020 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
49021 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
49022 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49023 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
49025 void* node_signer_ptr = untag_ptr(node_signer);
49026 CHECK_ACCESS(node_signer_ptr);
49027 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
49028 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
49029 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49030 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
49032 void* logger_ptr = untag_ptr(logger);
49033 CHECK_ACCESS(logger_ptr);
49034 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
49035 if (logger_conv.free == LDKLogger_JCalls_free) {
49036 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49037 LDKLogger_JCalls_cloned(&logger_conv);
49039 void* custom_handler_ptr = untag_ptr(custom_handler);
49040 CHECK_ACCESS(custom_handler_ptr);
49041 LDKCustomOnionMessageHandler custom_handler_conv = *(LDKCustomOnionMessageHandler*)(custom_handler_ptr);
49042 if (custom_handler_conv.free == LDKCustomOnionMessageHandler_JCalls_free) {
49043 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49044 LDKCustomOnionMessageHandler_JCalls_cloned(&custom_handler_conv);
49046 LDKOnionMessenger ret_var = OnionMessenger_new(entropy_source_conv, node_signer_conv, logger_conv, custom_handler_conv);
49047 uint64_t ret_ref = 0;
49048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49049 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49053 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) {
49054 LDKOnionMessenger this_arg_conv;
49055 this_arg_conv.inner = untag_ptr(this_arg);
49056 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49058 this_arg_conv.is_owned = false;
49059 LDKCVec_PublicKeyZ intermediate_nodes_constr;
49060 intermediate_nodes_constr.datalen = intermediate_nodes->arr_len;
49061 if (intermediate_nodes_constr.datalen > 0)
49062 intermediate_nodes_constr.data = MALLOC(intermediate_nodes_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
49064 intermediate_nodes_constr.data = NULL;
49065 int8_tArray* intermediate_nodes_vals = (void*) intermediate_nodes->elems;
49066 for (size_t m = 0; m < intermediate_nodes_constr.datalen; m++) {
49067 int8_tArray intermediate_nodes_conv_12 = intermediate_nodes_vals[m];
49068 LDKPublicKey intermediate_nodes_conv_12_ref;
49069 CHECK(intermediate_nodes_conv_12->arr_len == 33);
49070 memcpy(intermediate_nodes_conv_12_ref.compressed_form, intermediate_nodes_conv_12->elems, 33); FREE(intermediate_nodes_conv_12);
49071 intermediate_nodes_constr.data[m] = intermediate_nodes_conv_12_ref;
49073 FREE(intermediate_nodes);
49074 void* destination_ptr = untag_ptr(destination);
49075 CHECK_ACCESS(destination_ptr);
49076 LDKDestination destination_conv = *(LDKDestination*)(destination_ptr);
49077 destination_conv = Destination_clone((LDKDestination*)untag_ptr(destination));
49078 void* message_ptr = untag_ptr(message);
49079 CHECK_ACCESS(message_ptr);
49080 LDKOnionMessageContents message_conv = *(LDKOnionMessageContents*)(message_ptr);
49081 message_conv = OnionMessageContents_clone((LDKOnionMessageContents*)untag_ptr(message));
49082 LDKBlindedPath reply_path_conv;
49083 reply_path_conv.inner = untag_ptr(reply_path);
49084 reply_path_conv.is_owned = ptr_is_owned(reply_path);
49085 CHECK_INNER_FIELD_ACCESS_OR_NULL(reply_path_conv);
49086 reply_path_conv = BlindedPath_clone(&reply_path_conv);
49087 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
49088 *ret_conv = OnionMessenger_send_onion_message(&this_arg_conv, intermediate_nodes_constr, destination_conv, message_conv, reply_path_conv);
49089 return tag_ptr(ret_conv, true);
49092 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageHandler"))) TS_OnionMessenger_as_OnionMessageHandler(uint64_t this_arg) {
49093 LDKOnionMessenger this_arg_conv;
49094 this_arg_conv.inner = untag_ptr(this_arg);
49095 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49096 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49097 this_arg_conv.is_owned = false;
49098 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
49099 *ret_ret = OnionMessenger_as_OnionMessageHandler(&this_arg_conv);
49100 return tag_ptr(ret_ret, true);
49103 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageProvider"))) TS_OnionMessenger_as_OnionMessageProvider(uint64_t this_arg) {
49104 LDKOnionMessenger this_arg_conv;
49105 this_arg_conv.inner = untag_ptr(this_arg);
49106 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49108 this_arg_conv.is_owned = false;
49109 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
49110 *ret_ret = OnionMessenger_as_OnionMessageProvider(&this_arg_conv);
49111 return tag_ptr(ret_ret, true);
49114 void __attribute__((export_name("TS_OnionMessageContents_free"))) TS_OnionMessageContents_free(uint64_t this_ptr) {
49115 if (!ptr_is_owned(this_ptr)) return;
49116 void* this_ptr_ptr = untag_ptr(this_ptr);
49117 CHECK_ACCESS(this_ptr_ptr);
49118 LDKOnionMessageContents this_ptr_conv = *(LDKOnionMessageContents*)(this_ptr_ptr);
49119 FREE(untag_ptr(this_ptr));
49120 OnionMessageContents_free(this_ptr_conv);
49123 static inline uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg) {
49124 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
49125 *ret_copy = OnionMessageContents_clone(arg);
49126 uint64_t ret_ref = tag_ptr(ret_copy, true);
49129 int64_t __attribute__((export_name("TS_OnionMessageContents_clone_ptr"))) TS_OnionMessageContents_clone_ptr(uint64_t arg) {
49130 LDKOnionMessageContents* arg_conv = (LDKOnionMessageContents*)untag_ptr(arg);
49131 int64_t ret_conv = OnionMessageContents_clone_ptr(arg_conv);
49135 uint64_t __attribute__((export_name("TS_OnionMessageContents_clone"))) TS_OnionMessageContents_clone(uint64_t orig) {
49136 LDKOnionMessageContents* orig_conv = (LDKOnionMessageContents*)untag_ptr(orig);
49137 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
49138 *ret_copy = OnionMessageContents_clone(orig_conv);
49139 uint64_t ret_ref = tag_ptr(ret_copy, true);
49143 uint64_t __attribute__((export_name("TS_OnionMessageContents_custom"))) TS_OnionMessageContents_custom(uint64_t a) {
49144 void* a_ptr = untag_ptr(a);
49145 CHECK_ACCESS(a_ptr);
49146 LDKCustomOnionMessageContents a_conv = *(LDKCustomOnionMessageContents*)(a_ptr);
49147 if (a_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
49148 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
49149 LDKCustomOnionMessageContents_JCalls_cloned(&a_conv);
49151 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
49152 *ret_copy = OnionMessageContents_custom(a_conv);
49153 uint64_t ret_ref = tag_ptr(ret_copy, true);
49157 static inline uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg) {
49158 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
49159 *ret_ret = CustomOnionMessageContents_clone(arg);
49160 return tag_ptr(ret_ret, true);
49162 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone_ptr"))) TS_CustomOnionMessageContents_clone_ptr(uint64_t arg) {
49163 void* arg_ptr = untag_ptr(arg);
49164 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
49165 LDKCustomOnionMessageContents* arg_conv = (LDKCustomOnionMessageContents*)arg_ptr;
49166 int64_t ret_conv = CustomOnionMessageContents_clone_ptr(arg_conv);
49170 uint64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone"))) TS_CustomOnionMessageContents_clone(uint64_t orig) {
49171 void* orig_ptr = untag_ptr(orig);
49172 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
49173 LDKCustomOnionMessageContents* orig_conv = (LDKCustomOnionMessageContents*)orig_ptr;
49174 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
49175 *ret_ret = CustomOnionMessageContents_clone(orig_conv);
49176 return tag_ptr(ret_ret, true);
49179 void __attribute__((export_name("TS_CustomOnionMessageContents_free"))) TS_CustomOnionMessageContents_free(uint64_t this_ptr) {
49180 if (!ptr_is_owned(this_ptr)) return;
49181 void* this_ptr_ptr = untag_ptr(this_ptr);
49182 CHECK_ACCESS(this_ptr_ptr);
49183 LDKCustomOnionMessageContents this_ptr_conv = *(LDKCustomOnionMessageContents*)(this_ptr_ptr);
49184 FREE(untag_ptr(this_ptr));
49185 CustomOnionMessageContents_free(this_ptr_conv);
49188 void __attribute__((export_name("TS_BlindedPath_free"))) TS_BlindedPath_free(uint64_t this_obj) {
49189 LDKBlindedPath this_obj_conv;
49190 this_obj_conv.inner = untag_ptr(this_obj);
49191 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49192 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49193 BlindedPath_free(this_obj_conv);
49196 static inline uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg) {
49197 LDKBlindedPath ret_var = BlindedPath_clone(arg);
49198 uint64_t ret_ref = 0;
49199 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49200 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49203 int64_t __attribute__((export_name("TS_BlindedPath_clone_ptr"))) TS_BlindedPath_clone_ptr(uint64_t arg) {
49204 LDKBlindedPath arg_conv;
49205 arg_conv.inner = untag_ptr(arg);
49206 arg_conv.is_owned = ptr_is_owned(arg);
49207 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49208 arg_conv.is_owned = false;
49209 int64_t ret_conv = BlindedPath_clone_ptr(&arg_conv);
49213 uint64_t __attribute__((export_name("TS_BlindedPath_clone"))) TS_BlindedPath_clone(uint64_t orig) {
49214 LDKBlindedPath orig_conv;
49215 orig_conv.inner = untag_ptr(orig);
49216 orig_conv.is_owned = ptr_is_owned(orig);
49217 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49218 orig_conv.is_owned = false;
49219 LDKBlindedPath ret_var = BlindedPath_clone(&orig_conv);
49220 uint64_t ret_ref = 0;
49221 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49222 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49226 int64_t __attribute__((export_name("TS_BlindedPath_hash"))) TS_BlindedPath_hash(uint64_t o) {
49227 LDKBlindedPath o_conv;
49228 o_conv.inner = untag_ptr(o);
49229 o_conv.is_owned = ptr_is_owned(o);
49230 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
49231 o_conv.is_owned = false;
49232 int64_t ret_conv = BlindedPath_hash(&o_conv);
49236 jboolean __attribute__((export_name("TS_BlindedPath_eq"))) TS_BlindedPath_eq(uint64_t a, uint64_t b) {
49237 LDKBlindedPath a_conv;
49238 a_conv.inner = untag_ptr(a);
49239 a_conv.is_owned = ptr_is_owned(a);
49240 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49241 a_conv.is_owned = false;
49242 LDKBlindedPath b_conv;
49243 b_conv.inner = untag_ptr(b);
49244 b_conv.is_owned = ptr_is_owned(b);
49245 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49246 b_conv.is_owned = false;
49247 jboolean ret_conv = BlindedPath_eq(&a_conv, &b_conv);
49251 void __attribute__((export_name("TS_BlindedHop_free"))) TS_BlindedHop_free(uint64_t this_obj) {
49252 LDKBlindedHop this_obj_conv;
49253 this_obj_conv.inner = untag_ptr(this_obj);
49254 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49256 BlindedHop_free(this_obj_conv);
49259 static inline uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg) {
49260 LDKBlindedHop ret_var = BlindedHop_clone(arg);
49261 uint64_t ret_ref = 0;
49262 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49263 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49266 int64_t __attribute__((export_name("TS_BlindedHop_clone_ptr"))) TS_BlindedHop_clone_ptr(uint64_t arg) {
49267 LDKBlindedHop arg_conv;
49268 arg_conv.inner = untag_ptr(arg);
49269 arg_conv.is_owned = ptr_is_owned(arg);
49270 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49271 arg_conv.is_owned = false;
49272 int64_t ret_conv = BlindedHop_clone_ptr(&arg_conv);
49276 uint64_t __attribute__((export_name("TS_BlindedHop_clone"))) TS_BlindedHop_clone(uint64_t orig) {
49277 LDKBlindedHop orig_conv;
49278 orig_conv.inner = untag_ptr(orig);
49279 orig_conv.is_owned = ptr_is_owned(orig);
49280 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49281 orig_conv.is_owned = false;
49282 LDKBlindedHop ret_var = BlindedHop_clone(&orig_conv);
49283 uint64_t ret_ref = 0;
49284 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49285 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49289 int64_t __attribute__((export_name("TS_BlindedHop_hash"))) TS_BlindedHop_hash(uint64_t o) {
49290 LDKBlindedHop o_conv;
49291 o_conv.inner = untag_ptr(o);
49292 o_conv.is_owned = ptr_is_owned(o);
49293 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
49294 o_conv.is_owned = false;
49295 int64_t ret_conv = BlindedHop_hash(&o_conv);
49299 jboolean __attribute__((export_name("TS_BlindedHop_eq"))) TS_BlindedHop_eq(uint64_t a, uint64_t b) {
49300 LDKBlindedHop a_conv;
49301 a_conv.inner = untag_ptr(a);
49302 a_conv.is_owned = ptr_is_owned(a);
49303 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49304 a_conv.is_owned = false;
49305 LDKBlindedHop b_conv;
49306 b_conv.inner = untag_ptr(b);
49307 b_conv.is_owned = ptr_is_owned(b);
49308 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49309 b_conv.is_owned = false;
49310 jboolean ret_conv = BlindedHop_eq(&a_conv, &b_conv);
49314 uint64_t __attribute__((export_name("TS_BlindedPath_new_for_message"))) TS_BlindedPath_new_for_message(ptrArray node_pks, uint64_t entropy_source) {
49315 LDKCVec_PublicKeyZ node_pks_constr;
49316 node_pks_constr.datalen = node_pks->arr_len;
49317 if (node_pks_constr.datalen > 0)
49318 node_pks_constr.data = MALLOC(node_pks_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
49320 node_pks_constr.data = NULL;
49321 int8_tArray* node_pks_vals = (void*) node_pks->elems;
49322 for (size_t m = 0; m < node_pks_constr.datalen; m++) {
49323 int8_tArray node_pks_conv_12 = node_pks_vals[m];
49324 LDKPublicKey node_pks_conv_12_ref;
49325 CHECK(node_pks_conv_12->arr_len == 33);
49326 memcpy(node_pks_conv_12_ref.compressed_form, node_pks_conv_12->elems, 33); FREE(node_pks_conv_12);
49327 node_pks_constr.data[m] = node_pks_conv_12_ref;
49330 void* entropy_source_ptr = untag_ptr(entropy_source);
49331 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
49332 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
49333 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
49334 *ret_conv = BlindedPath_new_for_message(node_pks_constr, entropy_source_conv);
49335 return tag_ptr(ret_conv, true);
49338 int8_tArray __attribute__((export_name("TS_BlindedPath_write"))) TS_BlindedPath_write(uint64_t obj) {
49339 LDKBlindedPath obj_conv;
49340 obj_conv.inner = untag_ptr(obj);
49341 obj_conv.is_owned = ptr_is_owned(obj);
49342 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
49343 obj_conv.is_owned = false;
49344 LDKCVec_u8Z ret_var = BlindedPath_write(&obj_conv);
49345 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49346 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49347 CVec_u8Z_free(ret_var);
49351 uint64_t __attribute__((export_name("TS_BlindedPath_read"))) TS_BlindedPath_read(int8_tArray ser) {
49352 LDKu8slice ser_ref;
49353 ser_ref.datalen = ser->arr_len;
49354 ser_ref.data = ser->elems;
49355 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
49356 *ret_conv = BlindedPath_read(ser_ref);
49358 return tag_ptr(ret_conv, true);
49361 int8_tArray __attribute__((export_name("TS_BlindedHop_write"))) TS_BlindedHop_write(uint64_t obj) {
49362 LDKBlindedHop obj_conv;
49363 obj_conv.inner = untag_ptr(obj);
49364 obj_conv.is_owned = ptr_is_owned(obj);
49365 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
49366 obj_conv.is_owned = false;
49367 LDKCVec_u8Z ret_var = BlindedHop_write(&obj_conv);
49368 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49369 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49370 CVec_u8Z_free(ret_var);
49374 uint64_t __attribute__((export_name("TS_BlindedHop_read"))) TS_BlindedHop_read(int8_tArray ser) {
49375 LDKu8slice ser_ref;
49376 ser_ref.datalen = ser->arr_len;
49377 ser_ref.data = ser->elems;
49378 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
49379 *ret_conv = BlindedHop_read(ser_ref);
49381 return tag_ptr(ret_conv, true);
49384 void __attribute__((export_name("TS_PaymentPurpose_free"))) TS_PaymentPurpose_free(uint64_t this_ptr) {
49385 if (!ptr_is_owned(this_ptr)) return;
49386 void* this_ptr_ptr = untag_ptr(this_ptr);
49387 CHECK_ACCESS(this_ptr_ptr);
49388 LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(this_ptr_ptr);
49389 FREE(untag_ptr(this_ptr));
49390 PaymentPurpose_free(this_ptr_conv);
49393 static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
49394 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49395 *ret_copy = PaymentPurpose_clone(arg);
49396 uint64_t ret_ref = tag_ptr(ret_copy, true);
49399 int64_t __attribute__((export_name("TS_PaymentPurpose_clone_ptr"))) TS_PaymentPurpose_clone_ptr(uint64_t arg) {
49400 LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)untag_ptr(arg);
49401 int64_t ret_conv = PaymentPurpose_clone_ptr(arg_conv);
49405 uint64_t __attribute__((export_name("TS_PaymentPurpose_clone"))) TS_PaymentPurpose_clone(uint64_t orig) {
49406 LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)untag_ptr(orig);
49407 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49408 *ret_copy = PaymentPurpose_clone(orig_conv);
49409 uint64_t ret_ref = tag_ptr(ret_copy, true);
49413 uint64_t __attribute__((export_name("TS_PaymentPurpose_invoice_payment"))) TS_PaymentPurpose_invoice_payment(int8_tArray payment_preimage, int8_tArray payment_secret) {
49414 LDKThirtyTwoBytes payment_preimage_ref;
49415 CHECK(payment_preimage->arr_len == 32);
49416 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
49417 LDKThirtyTwoBytes payment_secret_ref;
49418 CHECK(payment_secret->arr_len == 32);
49419 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
49420 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49421 *ret_copy = PaymentPurpose_invoice_payment(payment_preimage_ref, payment_secret_ref);
49422 uint64_t ret_ref = tag_ptr(ret_copy, true);
49426 uint64_t __attribute__((export_name("TS_PaymentPurpose_spontaneous_payment"))) TS_PaymentPurpose_spontaneous_payment(int8_tArray a) {
49427 LDKThirtyTwoBytes a_ref;
49428 CHECK(a->arr_len == 32);
49429 memcpy(a_ref.data, a->elems, 32); FREE(a);
49430 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
49431 *ret_copy = PaymentPurpose_spontaneous_payment(a_ref);
49432 uint64_t ret_ref = tag_ptr(ret_copy, true);
49436 jboolean __attribute__((export_name("TS_PaymentPurpose_eq"))) TS_PaymentPurpose_eq(uint64_t a, uint64_t b) {
49437 LDKPaymentPurpose* a_conv = (LDKPaymentPurpose*)untag_ptr(a);
49438 LDKPaymentPurpose* b_conv = (LDKPaymentPurpose*)untag_ptr(b);
49439 jboolean ret_conv = PaymentPurpose_eq(a_conv, b_conv);
49443 int8_tArray __attribute__((export_name("TS_PaymentPurpose_write"))) TS_PaymentPurpose_write(uint64_t obj) {
49444 LDKPaymentPurpose* obj_conv = (LDKPaymentPurpose*)untag_ptr(obj);
49445 LDKCVec_u8Z ret_var = PaymentPurpose_write(obj_conv);
49446 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49447 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49448 CVec_u8Z_free(ret_var);
49452 uint64_t __attribute__((export_name("TS_PaymentPurpose_read"))) TS_PaymentPurpose_read(int8_tArray ser) {
49453 LDKu8slice ser_ref;
49454 ser_ref.datalen = ser->arr_len;
49455 ser_ref.data = ser->elems;
49456 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
49457 *ret_conv = PaymentPurpose_read(ser_ref);
49459 return tag_ptr(ret_conv, true);
49462 void __attribute__((export_name("TS_PathFailure_free"))) TS_PathFailure_free(uint64_t this_ptr) {
49463 if (!ptr_is_owned(this_ptr)) return;
49464 void* this_ptr_ptr = untag_ptr(this_ptr);
49465 CHECK_ACCESS(this_ptr_ptr);
49466 LDKPathFailure this_ptr_conv = *(LDKPathFailure*)(this_ptr_ptr);
49467 FREE(untag_ptr(this_ptr));
49468 PathFailure_free(this_ptr_conv);
49471 static inline uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg) {
49472 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49473 *ret_copy = PathFailure_clone(arg);
49474 uint64_t ret_ref = tag_ptr(ret_copy, true);
49477 int64_t __attribute__((export_name("TS_PathFailure_clone_ptr"))) TS_PathFailure_clone_ptr(uint64_t arg) {
49478 LDKPathFailure* arg_conv = (LDKPathFailure*)untag_ptr(arg);
49479 int64_t ret_conv = PathFailure_clone_ptr(arg_conv);
49483 uint64_t __attribute__((export_name("TS_PathFailure_clone"))) TS_PathFailure_clone(uint64_t orig) {
49484 LDKPathFailure* orig_conv = (LDKPathFailure*)untag_ptr(orig);
49485 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49486 *ret_copy = PathFailure_clone(orig_conv);
49487 uint64_t ret_ref = tag_ptr(ret_copy, true);
49491 uint64_t __attribute__((export_name("TS_PathFailure_initial_send"))) TS_PathFailure_initial_send(uint64_t err) {
49492 void* err_ptr = untag_ptr(err);
49493 CHECK_ACCESS(err_ptr);
49494 LDKAPIError err_conv = *(LDKAPIError*)(err_ptr);
49495 err_conv = APIError_clone((LDKAPIError*)untag_ptr(err));
49496 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49497 *ret_copy = PathFailure_initial_send(err_conv);
49498 uint64_t ret_ref = tag_ptr(ret_copy, true);
49502 uint64_t __attribute__((export_name("TS_PathFailure_on_path"))) TS_PathFailure_on_path(uint64_t network_update) {
49503 void* network_update_ptr = untag_ptr(network_update);
49504 CHECK_ACCESS(network_update_ptr);
49505 LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(network_update_ptr);
49506 network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(network_update));
49507 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
49508 *ret_copy = PathFailure_on_path(network_update_conv);
49509 uint64_t ret_ref = tag_ptr(ret_copy, true);
49513 jboolean __attribute__((export_name("TS_PathFailure_eq"))) TS_PathFailure_eq(uint64_t a, uint64_t b) {
49514 LDKPathFailure* a_conv = (LDKPathFailure*)untag_ptr(a);
49515 LDKPathFailure* b_conv = (LDKPathFailure*)untag_ptr(b);
49516 jboolean ret_conv = PathFailure_eq(a_conv, b_conv);
49520 int8_tArray __attribute__((export_name("TS_PathFailure_write"))) TS_PathFailure_write(uint64_t obj) {
49521 LDKPathFailure* obj_conv = (LDKPathFailure*)untag_ptr(obj);
49522 LDKCVec_u8Z ret_var = PathFailure_write(obj_conv);
49523 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49524 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49525 CVec_u8Z_free(ret_var);
49529 uint64_t __attribute__((export_name("TS_PathFailure_read"))) TS_PathFailure_read(int8_tArray ser) {
49530 LDKu8slice ser_ref;
49531 ser_ref.datalen = ser->arr_len;
49532 ser_ref.data = ser->elems;
49533 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
49534 *ret_conv = PathFailure_read(ser_ref);
49536 return tag_ptr(ret_conv, true);
49539 void __attribute__((export_name("TS_ClosureReason_free"))) TS_ClosureReason_free(uint64_t this_ptr) {
49540 if (!ptr_is_owned(this_ptr)) return;
49541 void* this_ptr_ptr = untag_ptr(this_ptr);
49542 CHECK_ACCESS(this_ptr_ptr);
49543 LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(this_ptr_ptr);
49544 FREE(untag_ptr(this_ptr));
49545 ClosureReason_free(this_ptr_conv);
49548 static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
49549 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49550 *ret_copy = ClosureReason_clone(arg);
49551 uint64_t ret_ref = tag_ptr(ret_copy, true);
49554 int64_t __attribute__((export_name("TS_ClosureReason_clone_ptr"))) TS_ClosureReason_clone_ptr(uint64_t arg) {
49555 LDKClosureReason* arg_conv = (LDKClosureReason*)untag_ptr(arg);
49556 int64_t ret_conv = ClosureReason_clone_ptr(arg_conv);
49560 uint64_t __attribute__((export_name("TS_ClosureReason_clone"))) TS_ClosureReason_clone(uint64_t orig) {
49561 LDKClosureReason* orig_conv = (LDKClosureReason*)untag_ptr(orig);
49562 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49563 *ret_copy = ClosureReason_clone(orig_conv);
49564 uint64_t ret_ref = tag_ptr(ret_copy, true);
49568 uint64_t __attribute__((export_name("TS_ClosureReason_counterparty_force_closed"))) TS_ClosureReason_counterparty_force_closed(uint64_t peer_msg) {
49569 LDKUntrustedString peer_msg_conv;
49570 peer_msg_conv.inner = untag_ptr(peer_msg);
49571 peer_msg_conv.is_owned = ptr_is_owned(peer_msg);
49572 CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_msg_conv);
49573 peer_msg_conv = UntrustedString_clone(&peer_msg_conv);
49574 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49575 *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv);
49576 uint64_t ret_ref = tag_ptr(ret_copy, true);
49580 uint64_t __attribute__((export_name("TS_ClosureReason_holder_force_closed"))) TS_ClosureReason_holder_force_closed() {
49581 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49582 *ret_copy = ClosureReason_holder_force_closed();
49583 uint64_t ret_ref = tag_ptr(ret_copy, true);
49587 uint64_t __attribute__((export_name("TS_ClosureReason_cooperative_closure"))) TS_ClosureReason_cooperative_closure() {
49588 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49589 *ret_copy = ClosureReason_cooperative_closure();
49590 uint64_t ret_ref = tag_ptr(ret_copy, true);
49594 uint64_t __attribute__((export_name("TS_ClosureReason_commitment_tx_confirmed"))) TS_ClosureReason_commitment_tx_confirmed() {
49595 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49596 *ret_copy = ClosureReason_commitment_tx_confirmed();
49597 uint64_t ret_ref = tag_ptr(ret_copy, true);
49601 uint64_t __attribute__((export_name("TS_ClosureReason_funding_timed_out"))) TS_ClosureReason_funding_timed_out() {
49602 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49603 *ret_copy = ClosureReason_funding_timed_out();
49604 uint64_t ret_ref = tag_ptr(ret_copy, true);
49608 uint64_t __attribute__((export_name("TS_ClosureReason_processing_error"))) TS_ClosureReason_processing_error(jstring err) {
49609 LDKStr err_conv = str_ref_to_owned_c(err);
49610 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49611 *ret_copy = ClosureReason_processing_error(err_conv);
49612 uint64_t ret_ref = tag_ptr(ret_copy, true);
49616 uint64_t __attribute__((export_name("TS_ClosureReason_disconnected_peer"))) TS_ClosureReason_disconnected_peer() {
49617 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49618 *ret_copy = ClosureReason_disconnected_peer();
49619 uint64_t ret_ref = tag_ptr(ret_copy, true);
49623 uint64_t __attribute__((export_name("TS_ClosureReason_outdated_channel_manager"))) TS_ClosureReason_outdated_channel_manager() {
49624 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
49625 *ret_copy = ClosureReason_outdated_channel_manager();
49626 uint64_t ret_ref = tag_ptr(ret_copy, true);
49630 jboolean __attribute__((export_name("TS_ClosureReason_eq"))) TS_ClosureReason_eq(uint64_t a, uint64_t b) {
49631 LDKClosureReason* a_conv = (LDKClosureReason*)untag_ptr(a);
49632 LDKClosureReason* b_conv = (LDKClosureReason*)untag_ptr(b);
49633 jboolean ret_conv = ClosureReason_eq(a_conv, b_conv);
49637 int8_tArray __attribute__((export_name("TS_ClosureReason_write"))) TS_ClosureReason_write(uint64_t obj) {
49638 LDKClosureReason* obj_conv = (LDKClosureReason*)untag_ptr(obj);
49639 LDKCVec_u8Z ret_var = ClosureReason_write(obj_conv);
49640 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49641 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49642 CVec_u8Z_free(ret_var);
49646 uint64_t __attribute__((export_name("TS_ClosureReason_read"))) TS_ClosureReason_read(int8_tArray ser) {
49647 LDKu8slice ser_ref;
49648 ser_ref.datalen = ser->arr_len;
49649 ser_ref.data = ser->elems;
49650 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
49651 *ret_conv = ClosureReason_read(ser_ref);
49653 return tag_ptr(ret_conv, true);
49656 void __attribute__((export_name("TS_HTLCDestination_free"))) TS_HTLCDestination_free(uint64_t this_ptr) {
49657 if (!ptr_is_owned(this_ptr)) return;
49658 void* this_ptr_ptr = untag_ptr(this_ptr);
49659 CHECK_ACCESS(this_ptr_ptr);
49660 LDKHTLCDestination this_ptr_conv = *(LDKHTLCDestination*)(this_ptr_ptr);
49661 FREE(untag_ptr(this_ptr));
49662 HTLCDestination_free(this_ptr_conv);
49665 static inline uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg) {
49666 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49667 *ret_copy = HTLCDestination_clone(arg);
49668 uint64_t ret_ref = tag_ptr(ret_copy, true);
49671 int64_t __attribute__((export_name("TS_HTLCDestination_clone_ptr"))) TS_HTLCDestination_clone_ptr(uint64_t arg) {
49672 LDKHTLCDestination* arg_conv = (LDKHTLCDestination*)untag_ptr(arg);
49673 int64_t ret_conv = HTLCDestination_clone_ptr(arg_conv);
49677 uint64_t __attribute__((export_name("TS_HTLCDestination_clone"))) TS_HTLCDestination_clone(uint64_t orig) {
49678 LDKHTLCDestination* orig_conv = (LDKHTLCDestination*)untag_ptr(orig);
49679 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49680 *ret_copy = HTLCDestination_clone(orig_conv);
49681 uint64_t ret_ref = tag_ptr(ret_copy, true);
49685 uint64_t __attribute__((export_name("TS_HTLCDestination_next_hop_channel"))) TS_HTLCDestination_next_hop_channel(int8_tArray node_id, int8_tArray channel_id) {
49686 LDKPublicKey node_id_ref;
49687 CHECK(node_id->arr_len == 33);
49688 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
49689 LDKThirtyTwoBytes channel_id_ref;
49690 CHECK(channel_id->arr_len == 32);
49691 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
49692 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49693 *ret_copy = HTLCDestination_next_hop_channel(node_id_ref, channel_id_ref);
49694 uint64_t ret_ref = tag_ptr(ret_copy, true);
49698 uint64_t __attribute__((export_name("TS_HTLCDestination_unknown_next_hop"))) TS_HTLCDestination_unknown_next_hop(int64_t requested_forward_scid) {
49699 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49700 *ret_copy = HTLCDestination_unknown_next_hop(requested_forward_scid);
49701 uint64_t ret_ref = tag_ptr(ret_copy, true);
49705 uint64_t __attribute__((export_name("TS_HTLCDestination_invalid_forward"))) TS_HTLCDestination_invalid_forward(int64_t requested_forward_scid) {
49706 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49707 *ret_copy = HTLCDestination_invalid_forward(requested_forward_scid);
49708 uint64_t ret_ref = tag_ptr(ret_copy, true);
49712 uint64_t __attribute__((export_name("TS_HTLCDestination_failed_payment"))) TS_HTLCDestination_failed_payment(int8_tArray payment_hash) {
49713 LDKThirtyTwoBytes payment_hash_ref;
49714 CHECK(payment_hash->arr_len == 32);
49715 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49716 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
49717 *ret_copy = HTLCDestination_failed_payment(payment_hash_ref);
49718 uint64_t ret_ref = tag_ptr(ret_copy, true);
49722 jboolean __attribute__((export_name("TS_HTLCDestination_eq"))) TS_HTLCDestination_eq(uint64_t a, uint64_t b) {
49723 LDKHTLCDestination* a_conv = (LDKHTLCDestination*)untag_ptr(a);
49724 LDKHTLCDestination* b_conv = (LDKHTLCDestination*)untag_ptr(b);
49725 jboolean ret_conv = HTLCDestination_eq(a_conv, b_conv);
49729 int8_tArray __attribute__((export_name("TS_HTLCDestination_write"))) TS_HTLCDestination_write(uint64_t obj) {
49730 LDKHTLCDestination* obj_conv = (LDKHTLCDestination*)untag_ptr(obj);
49731 LDKCVec_u8Z ret_var = HTLCDestination_write(obj_conv);
49732 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49733 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49734 CVec_u8Z_free(ret_var);
49738 uint64_t __attribute__((export_name("TS_HTLCDestination_read"))) TS_HTLCDestination_read(int8_tArray ser) {
49739 LDKu8slice ser_ref;
49740 ser_ref.datalen = ser->arr_len;
49741 ser_ref.data = ser->elems;
49742 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
49743 *ret_conv = HTLCDestination_read(ser_ref);
49745 return tag_ptr(ret_conv, true);
49748 uint32_t __attribute__((export_name("TS_PaymentFailureReason_clone"))) TS_PaymentFailureReason_clone(uint64_t orig) {
49749 LDKPaymentFailureReason* orig_conv = (LDKPaymentFailureReason*)untag_ptr(orig);
49750 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_clone(orig_conv));
49754 uint32_t __attribute__((export_name("TS_PaymentFailureReason_recipient_rejected"))) TS_PaymentFailureReason_recipient_rejected() {
49755 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_recipient_rejected());
49759 uint32_t __attribute__((export_name("TS_PaymentFailureReason_user_abandoned"))) TS_PaymentFailureReason_user_abandoned() {
49760 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_user_abandoned());
49764 uint32_t __attribute__((export_name("TS_PaymentFailureReason_retries_exhausted"))) TS_PaymentFailureReason_retries_exhausted() {
49765 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_retries_exhausted());
49769 uint32_t __attribute__((export_name("TS_PaymentFailureReason_payment_expired"))) TS_PaymentFailureReason_payment_expired() {
49770 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_payment_expired());
49774 uint32_t __attribute__((export_name("TS_PaymentFailureReason_route_not_found"))) TS_PaymentFailureReason_route_not_found() {
49775 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_route_not_found());
49779 uint32_t __attribute__((export_name("TS_PaymentFailureReason_unexpected_error"))) TS_PaymentFailureReason_unexpected_error() {
49780 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_unexpected_error());
49784 jboolean __attribute__((export_name("TS_PaymentFailureReason_eq"))) TS_PaymentFailureReason_eq(uint64_t a, uint64_t b) {
49785 LDKPaymentFailureReason* a_conv = (LDKPaymentFailureReason*)untag_ptr(a);
49786 LDKPaymentFailureReason* b_conv = (LDKPaymentFailureReason*)untag_ptr(b);
49787 jboolean ret_conv = PaymentFailureReason_eq(a_conv, b_conv);
49791 int8_tArray __attribute__((export_name("TS_PaymentFailureReason_write"))) TS_PaymentFailureReason_write(uint64_t obj) {
49792 LDKPaymentFailureReason* obj_conv = (LDKPaymentFailureReason*)untag_ptr(obj);
49793 LDKCVec_u8Z ret_var = PaymentFailureReason_write(obj_conv);
49794 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
49795 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
49796 CVec_u8Z_free(ret_var);
49800 uint64_t __attribute__((export_name("TS_PaymentFailureReason_read"))) TS_PaymentFailureReason_read(int8_tArray ser) {
49801 LDKu8slice ser_ref;
49802 ser_ref.datalen = ser->arr_len;
49803 ser_ref.data = ser->elems;
49804 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
49805 *ret_conv = PaymentFailureReason_read(ser_ref);
49807 return tag_ptr(ret_conv, true);
49810 void __attribute__((export_name("TS_Event_free"))) TS_Event_free(uint64_t this_ptr) {
49811 if (!ptr_is_owned(this_ptr)) return;
49812 void* this_ptr_ptr = untag_ptr(this_ptr);
49813 CHECK_ACCESS(this_ptr_ptr);
49814 LDKEvent this_ptr_conv = *(LDKEvent*)(this_ptr_ptr);
49815 FREE(untag_ptr(this_ptr));
49816 Event_free(this_ptr_conv);
49819 static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
49820 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49821 *ret_copy = Event_clone(arg);
49822 uint64_t ret_ref = tag_ptr(ret_copy, true);
49825 int64_t __attribute__((export_name("TS_Event_clone_ptr"))) TS_Event_clone_ptr(uint64_t arg) {
49826 LDKEvent* arg_conv = (LDKEvent*)untag_ptr(arg);
49827 int64_t ret_conv = Event_clone_ptr(arg_conv);
49831 uint64_t __attribute__((export_name("TS_Event_clone"))) TS_Event_clone(uint64_t orig) {
49832 LDKEvent* orig_conv = (LDKEvent*)untag_ptr(orig);
49833 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49834 *ret_copy = Event_clone(orig_conv);
49835 uint64_t ret_ref = tag_ptr(ret_copy, true);
49839 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) {
49840 LDKThirtyTwoBytes temporary_channel_id_ref;
49841 CHECK(temporary_channel_id->arr_len == 32);
49842 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
49843 LDKPublicKey counterparty_node_id_ref;
49844 CHECK(counterparty_node_id->arr_len == 33);
49845 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
49846 LDKCVec_u8Z output_script_ref;
49847 output_script_ref.datalen = output_script->arr_len;
49848 output_script_ref.data = MALLOC(output_script_ref.datalen, "LDKCVec_u8Z Bytes");
49849 memcpy(output_script_ref.data, output_script->elems, output_script_ref.datalen); FREE(output_script);
49850 LDKU128 user_channel_id_ref;
49851 CHECK(user_channel_id->arr_len == 16);
49852 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
49853 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49854 *ret_copy = Event_funding_generation_ready(temporary_channel_id_ref, counterparty_node_id_ref, channel_value_satoshis, output_script_ref, user_channel_id_ref);
49855 uint64_t ret_ref = tag_ptr(ret_copy, true);
49859 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) {
49860 LDKPublicKey receiver_node_id_ref;
49861 CHECK(receiver_node_id->arr_len == 33);
49862 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
49863 LDKThirtyTwoBytes payment_hash_ref;
49864 CHECK(payment_hash->arr_len == 32);
49865 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49866 LDKRecipientOnionFields onion_fields_conv;
49867 onion_fields_conv.inner = untag_ptr(onion_fields);
49868 onion_fields_conv.is_owned = ptr_is_owned(onion_fields);
49869 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_fields_conv);
49870 onion_fields_conv = RecipientOnionFields_clone(&onion_fields_conv);
49871 void* purpose_ptr = untag_ptr(purpose);
49872 CHECK_ACCESS(purpose_ptr);
49873 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
49874 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
49875 LDKThirtyTwoBytes via_channel_id_ref;
49876 CHECK(via_channel_id->arr_len == 32);
49877 memcpy(via_channel_id_ref.data, via_channel_id->elems, 32); FREE(via_channel_id);
49878 void* via_user_channel_id_ptr = untag_ptr(via_user_channel_id);
49879 CHECK_ACCESS(via_user_channel_id_ptr);
49880 LDKCOption_u128Z via_user_channel_id_conv = *(LDKCOption_u128Z*)(via_user_channel_id_ptr);
49881 via_user_channel_id_conv = COption_u128Z_clone((LDKCOption_u128Z*)untag_ptr(via_user_channel_id));
49882 void* claim_deadline_ptr = untag_ptr(claim_deadline);
49883 CHECK_ACCESS(claim_deadline_ptr);
49884 LDKCOption_u32Z claim_deadline_conv = *(LDKCOption_u32Z*)(claim_deadline_ptr);
49885 claim_deadline_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(claim_deadline));
49886 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49887 *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);
49888 uint64_t ret_ref = tag_ptr(ret_copy, true);
49892 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) {
49893 LDKPublicKey receiver_node_id_ref;
49894 CHECK(receiver_node_id->arr_len == 33);
49895 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
49896 LDKThirtyTwoBytes payment_hash_ref;
49897 CHECK(payment_hash->arr_len == 32);
49898 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49899 void* purpose_ptr = untag_ptr(purpose);
49900 CHECK_ACCESS(purpose_ptr);
49901 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
49902 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
49903 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49904 *ret_copy = Event_payment_claimed(receiver_node_id_ref, payment_hash_ref, amount_msat, purpose_conv);
49905 uint64_t ret_ref = tag_ptr(ret_copy, true);
49909 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) {
49910 LDKThirtyTwoBytes payment_id_ref;
49911 CHECK(payment_id->arr_len == 32);
49912 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49913 LDKThirtyTwoBytes payment_preimage_ref;
49914 CHECK(payment_preimage->arr_len == 32);
49915 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
49916 LDKThirtyTwoBytes payment_hash_ref;
49917 CHECK(payment_hash->arr_len == 32);
49918 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49919 void* fee_paid_msat_ptr = untag_ptr(fee_paid_msat);
49920 CHECK_ACCESS(fee_paid_msat_ptr);
49921 LDKCOption_u64Z fee_paid_msat_conv = *(LDKCOption_u64Z*)(fee_paid_msat_ptr);
49922 fee_paid_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_paid_msat));
49923 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49924 *ret_copy = Event_payment_sent(payment_id_ref, payment_preimage_ref, payment_hash_ref, fee_paid_msat_conv);
49925 uint64_t ret_ref = tag_ptr(ret_copy, true);
49929 uint64_t __attribute__((export_name("TS_Event_payment_failed"))) TS_Event_payment_failed(int8_tArray payment_id, int8_tArray payment_hash, uint64_t reason) {
49930 LDKThirtyTwoBytes payment_id_ref;
49931 CHECK(payment_id->arr_len == 32);
49932 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49933 LDKThirtyTwoBytes payment_hash_ref;
49934 CHECK(payment_hash->arr_len == 32);
49935 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49936 void* reason_ptr = untag_ptr(reason);
49937 CHECK_ACCESS(reason_ptr);
49938 LDKCOption_PaymentFailureReasonZ reason_conv = *(LDKCOption_PaymentFailureReasonZ*)(reason_ptr);
49939 reason_conv = COption_PaymentFailureReasonZ_clone((LDKCOption_PaymentFailureReasonZ*)untag_ptr(reason));
49940 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49941 *ret_copy = Event_payment_failed(payment_id_ref, payment_hash_ref, reason_conv);
49942 uint64_t ret_ref = tag_ptr(ret_copy, true);
49946 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) {
49947 LDKThirtyTwoBytes payment_id_ref;
49948 CHECK(payment_id->arr_len == 32);
49949 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49950 LDKThirtyTwoBytes payment_hash_ref;
49951 CHECK(payment_hash->arr_len == 32);
49952 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49954 path_conv.inner = untag_ptr(path);
49955 path_conv.is_owned = ptr_is_owned(path);
49956 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
49957 path_conv = Path_clone(&path_conv);
49958 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49959 *ret_copy = Event_payment_path_successful(payment_id_ref, payment_hash_ref, path_conv);
49960 uint64_t ret_ref = tag_ptr(ret_copy, true);
49964 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) {
49965 LDKThirtyTwoBytes payment_id_ref;
49966 CHECK(payment_id->arr_len == 32);
49967 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49968 LDKThirtyTwoBytes payment_hash_ref;
49969 CHECK(payment_hash->arr_len == 32);
49970 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49971 void* failure_ptr = untag_ptr(failure);
49972 CHECK_ACCESS(failure_ptr);
49973 LDKPathFailure failure_conv = *(LDKPathFailure*)(failure_ptr);
49974 failure_conv = PathFailure_clone((LDKPathFailure*)untag_ptr(failure));
49976 path_conv.inner = untag_ptr(path);
49977 path_conv.is_owned = ptr_is_owned(path);
49978 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
49979 path_conv = Path_clone(&path_conv);
49980 void* short_channel_id_ptr = untag_ptr(short_channel_id);
49981 CHECK_ACCESS(short_channel_id_ptr);
49982 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
49983 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
49984 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
49985 *ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, payment_failed_permanently, failure_conv, path_conv, short_channel_id_conv);
49986 uint64_t ret_ref = tag_ptr(ret_copy, true);
49990 uint64_t __attribute__((export_name("TS_Event_probe_successful"))) TS_Event_probe_successful(int8_tArray payment_id, int8_tArray payment_hash, uint64_t path) {
49991 LDKThirtyTwoBytes payment_id_ref;
49992 CHECK(payment_id->arr_len == 32);
49993 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
49994 LDKThirtyTwoBytes payment_hash_ref;
49995 CHECK(payment_hash->arr_len == 32);
49996 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
49998 path_conv.inner = untag_ptr(path);
49999 path_conv.is_owned = ptr_is_owned(path);
50000 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
50001 path_conv = Path_clone(&path_conv);
50002 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50003 *ret_copy = Event_probe_successful(payment_id_ref, payment_hash_ref, path_conv);
50004 uint64_t ret_ref = tag_ptr(ret_copy, true);
50008 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) {
50009 LDKThirtyTwoBytes payment_id_ref;
50010 CHECK(payment_id->arr_len == 32);
50011 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
50012 LDKThirtyTwoBytes payment_hash_ref;
50013 CHECK(payment_hash->arr_len == 32);
50014 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
50016 path_conv.inner = untag_ptr(path);
50017 path_conv.is_owned = ptr_is_owned(path);
50018 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
50019 path_conv = Path_clone(&path_conv);
50020 void* short_channel_id_ptr = untag_ptr(short_channel_id);
50021 CHECK_ACCESS(short_channel_id_ptr);
50022 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
50023 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
50024 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50025 *ret_copy = Event_probe_failed(payment_id_ref, payment_hash_ref, path_conv, short_channel_id_conv);
50026 uint64_t ret_ref = tag_ptr(ret_copy, true);
50030 uint64_t __attribute__((export_name("TS_Event_pending_htlcs_forwardable"))) TS_Event_pending_htlcs_forwardable(int64_t time_forwardable) {
50031 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50032 *ret_copy = Event_pending_htlcs_forwardable(time_forwardable);
50033 uint64_t ret_ref = tag_ptr(ret_copy, true);
50037 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) {
50038 LDKThirtyTwoBytes intercept_id_ref;
50039 CHECK(intercept_id->arr_len == 32);
50040 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
50041 LDKThirtyTwoBytes payment_hash_ref;
50042 CHECK(payment_hash->arr_len == 32);
50043 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
50044 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50045 *ret_copy = Event_htlcintercepted(intercept_id_ref, requested_next_hop_scid, payment_hash_ref, inbound_amount_msat, expected_outbound_amount_msat);
50046 uint64_t ret_ref = tag_ptr(ret_copy, true);
50050 uint64_t __attribute__((export_name("TS_Event_spendable_outputs"))) TS_Event_spendable_outputs(uint64_tArray outputs) {
50051 LDKCVec_SpendableOutputDescriptorZ outputs_constr;
50052 outputs_constr.datalen = outputs->arr_len;
50053 if (outputs_constr.datalen > 0)
50054 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
50056 outputs_constr.data = NULL;
50057 uint64_t* outputs_vals = outputs->elems;
50058 for (size_t b = 0; b < outputs_constr.datalen; b++) {
50059 uint64_t outputs_conv_27 = outputs_vals[b];
50060 void* outputs_conv_27_ptr = untag_ptr(outputs_conv_27);
50061 CHECK_ACCESS(outputs_conv_27_ptr);
50062 LDKSpendableOutputDescriptor outputs_conv_27_conv = *(LDKSpendableOutputDescriptor*)(outputs_conv_27_ptr);
50063 outputs_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(outputs_conv_27));
50064 outputs_constr.data[b] = outputs_conv_27_conv;
50067 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50068 *ret_copy = Event_spendable_outputs(outputs_constr);
50069 uint64_t ret_ref = tag_ptr(ret_copy, true);
50073 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) {
50074 LDKThirtyTwoBytes prev_channel_id_ref;
50075 CHECK(prev_channel_id->arr_len == 32);
50076 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
50077 LDKThirtyTwoBytes next_channel_id_ref;
50078 CHECK(next_channel_id->arr_len == 32);
50079 memcpy(next_channel_id_ref.data, next_channel_id->elems, 32); FREE(next_channel_id);
50080 void* fee_earned_msat_ptr = untag_ptr(fee_earned_msat);
50081 CHECK_ACCESS(fee_earned_msat_ptr);
50082 LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(fee_earned_msat_ptr);
50083 fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_earned_msat));
50084 void* outbound_amount_forwarded_msat_ptr = untag_ptr(outbound_amount_forwarded_msat);
50085 CHECK_ACCESS(outbound_amount_forwarded_msat_ptr);
50086 LDKCOption_u64Z outbound_amount_forwarded_msat_conv = *(LDKCOption_u64Z*)(outbound_amount_forwarded_msat_ptr);
50087 outbound_amount_forwarded_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_amount_forwarded_msat));
50088 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50089 *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);
50090 uint64_t ret_ref = tag_ptr(ret_copy, true);
50094 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) {
50095 LDKThirtyTwoBytes channel_id_ref;
50096 CHECK(channel_id->arr_len == 32);
50097 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50098 LDKU128 user_channel_id_ref;
50099 CHECK(user_channel_id->arr_len == 16);
50100 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
50101 LDKThirtyTwoBytes former_temporary_channel_id_ref;
50102 CHECK(former_temporary_channel_id->arr_len == 32);
50103 memcpy(former_temporary_channel_id_ref.data, former_temporary_channel_id->elems, 32); FREE(former_temporary_channel_id);
50104 LDKPublicKey counterparty_node_id_ref;
50105 CHECK(counterparty_node_id->arr_len == 33);
50106 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
50107 LDKOutPoint funding_txo_conv;
50108 funding_txo_conv.inner = untag_ptr(funding_txo);
50109 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
50110 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
50111 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
50112 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50113 *ret_copy = Event_channel_pending(channel_id_ref, user_channel_id_ref, former_temporary_channel_id_ref, counterparty_node_id_ref, funding_txo_conv);
50114 uint64_t ret_ref = tag_ptr(ret_copy, true);
50118 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) {
50119 LDKThirtyTwoBytes channel_id_ref;
50120 CHECK(channel_id->arr_len == 32);
50121 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50122 LDKU128 user_channel_id_ref;
50123 CHECK(user_channel_id->arr_len == 16);
50124 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
50125 LDKPublicKey counterparty_node_id_ref;
50126 CHECK(counterparty_node_id->arr_len == 33);
50127 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
50128 LDKChannelTypeFeatures channel_type_conv;
50129 channel_type_conv.inner = untag_ptr(channel_type);
50130 channel_type_conv.is_owned = ptr_is_owned(channel_type);
50131 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
50132 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
50133 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50134 *ret_copy = Event_channel_ready(channel_id_ref, user_channel_id_ref, counterparty_node_id_ref, channel_type_conv);
50135 uint64_t ret_ref = tag_ptr(ret_copy, true);
50139 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) {
50140 LDKThirtyTwoBytes channel_id_ref;
50141 CHECK(channel_id->arr_len == 32);
50142 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50143 LDKU128 user_channel_id_ref;
50144 CHECK(user_channel_id->arr_len == 16);
50145 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
50146 void* reason_ptr = untag_ptr(reason);
50147 CHECK_ACCESS(reason_ptr);
50148 LDKClosureReason reason_conv = *(LDKClosureReason*)(reason_ptr);
50149 reason_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(reason));
50150 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50151 *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id_ref, reason_conv);
50152 uint64_t ret_ref = tag_ptr(ret_copy, true);
50156 uint64_t __attribute__((export_name("TS_Event_discard_funding"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) {
50157 LDKThirtyTwoBytes channel_id_ref;
50158 CHECK(channel_id->arr_len == 32);
50159 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
50160 LDKTransaction transaction_ref;
50161 transaction_ref.datalen = transaction->arr_len;
50162 transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
50163 memcpy(transaction_ref.data, transaction->elems, transaction_ref.datalen); FREE(transaction);
50164 transaction_ref.data_is_owned = true;
50165 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50166 *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref);
50167 uint64_t ret_ref = tag_ptr(ret_copy, true);
50171 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) {
50172 LDKThirtyTwoBytes temporary_channel_id_ref;
50173 CHECK(temporary_channel_id->arr_len == 32);
50174 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
50175 LDKPublicKey counterparty_node_id_ref;
50176 CHECK(counterparty_node_id->arr_len == 33);
50177 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
50178 LDKChannelTypeFeatures channel_type_conv;
50179 channel_type_conv.inner = untag_ptr(channel_type);
50180 channel_type_conv.is_owned = ptr_is_owned(channel_type);
50181 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
50182 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
50183 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50184 *ret_copy = Event_open_channel_request(temporary_channel_id_ref, counterparty_node_id_ref, funding_satoshis, push_msat, channel_type_conv);
50185 uint64_t ret_ref = tag_ptr(ret_copy, true);
50189 uint64_t __attribute__((export_name("TS_Event_htlchandling_failed"))) TS_Event_htlchandling_failed(int8_tArray prev_channel_id, uint64_t failed_next_destination) {
50190 LDKThirtyTwoBytes prev_channel_id_ref;
50191 CHECK(prev_channel_id->arr_len == 32);
50192 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
50193 void* failed_next_destination_ptr = untag_ptr(failed_next_destination);
50194 CHECK_ACCESS(failed_next_destination_ptr);
50195 LDKHTLCDestination failed_next_destination_conv = *(LDKHTLCDestination*)(failed_next_destination_ptr);
50196 failed_next_destination_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(failed_next_destination));
50197 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
50198 *ret_copy = Event_htlchandling_failed(prev_channel_id_ref, failed_next_destination_conv);
50199 uint64_t ret_ref = tag_ptr(ret_copy, true);
50203 jboolean __attribute__((export_name("TS_Event_eq"))) TS_Event_eq(uint64_t a, uint64_t b) {
50204 LDKEvent* a_conv = (LDKEvent*)untag_ptr(a);
50205 LDKEvent* b_conv = (LDKEvent*)untag_ptr(b);
50206 jboolean ret_conv = Event_eq(a_conv, b_conv);
50210 int8_tArray __attribute__((export_name("TS_Event_write"))) TS_Event_write(uint64_t obj) {
50211 LDKEvent* obj_conv = (LDKEvent*)untag_ptr(obj);
50212 LDKCVec_u8Z ret_var = Event_write(obj_conv);
50213 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50214 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50215 CVec_u8Z_free(ret_var);
50219 uint64_t __attribute__((export_name("TS_Event_read"))) TS_Event_read(int8_tArray ser) {
50220 LDKu8slice ser_ref;
50221 ser_ref.datalen = ser->arr_len;
50222 ser_ref.data = ser->elems;
50223 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
50224 *ret_conv = Event_read(ser_ref);
50226 return tag_ptr(ret_conv, true);
50229 void __attribute__((export_name("TS_MessageSendEvent_free"))) TS_MessageSendEvent_free(uint64_t this_ptr) {
50230 if (!ptr_is_owned(this_ptr)) return;
50231 void* this_ptr_ptr = untag_ptr(this_ptr);
50232 CHECK_ACCESS(this_ptr_ptr);
50233 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(this_ptr_ptr);
50234 FREE(untag_ptr(this_ptr));
50235 MessageSendEvent_free(this_ptr_conv);
50238 static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
50239 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50240 *ret_copy = MessageSendEvent_clone(arg);
50241 uint64_t ret_ref = tag_ptr(ret_copy, true);
50244 int64_t __attribute__((export_name("TS_MessageSendEvent_clone_ptr"))) TS_MessageSendEvent_clone_ptr(uint64_t arg) {
50245 LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)untag_ptr(arg);
50246 int64_t ret_conv = MessageSendEvent_clone_ptr(arg_conv);
50250 uint64_t __attribute__((export_name("TS_MessageSendEvent_clone"))) TS_MessageSendEvent_clone(uint64_t orig) {
50251 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)untag_ptr(orig);
50252 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50253 *ret_copy = MessageSendEvent_clone(orig_conv);
50254 uint64_t ret_ref = tag_ptr(ret_copy, true);
50258 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_accept_channel"))) TS_MessageSendEvent_send_accept_channel(int8_tArray node_id, uint64_t msg) {
50259 LDKPublicKey node_id_ref;
50260 CHECK(node_id->arr_len == 33);
50261 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50262 LDKAcceptChannel msg_conv;
50263 msg_conv.inner = untag_ptr(msg);
50264 msg_conv.is_owned = ptr_is_owned(msg);
50265 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50266 msg_conv = AcceptChannel_clone(&msg_conv);
50267 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50268 *ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
50269 uint64_t ret_ref = tag_ptr(ret_copy, true);
50273 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_open_channel"))) TS_MessageSendEvent_send_open_channel(int8_tArray node_id, uint64_t msg) {
50274 LDKPublicKey node_id_ref;
50275 CHECK(node_id->arr_len == 33);
50276 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50277 LDKOpenChannel msg_conv;
50278 msg_conv.inner = untag_ptr(msg);
50279 msg_conv.is_owned = ptr_is_owned(msg);
50280 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50281 msg_conv = OpenChannel_clone(&msg_conv);
50282 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50283 *ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
50284 uint64_t ret_ref = tag_ptr(ret_copy, true);
50288 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_created"))) TS_MessageSendEvent_send_funding_created(int8_tArray node_id, uint64_t msg) {
50289 LDKPublicKey node_id_ref;
50290 CHECK(node_id->arr_len == 33);
50291 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50292 LDKFundingCreated msg_conv;
50293 msg_conv.inner = untag_ptr(msg);
50294 msg_conv.is_owned = ptr_is_owned(msg);
50295 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50296 msg_conv = FundingCreated_clone(&msg_conv);
50297 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50298 *ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
50299 uint64_t ret_ref = tag_ptr(ret_copy, true);
50303 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_signed"))) TS_MessageSendEvent_send_funding_signed(int8_tArray node_id, uint64_t msg) {
50304 LDKPublicKey node_id_ref;
50305 CHECK(node_id->arr_len == 33);
50306 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50307 LDKFundingSigned msg_conv;
50308 msg_conv.inner = untag_ptr(msg);
50309 msg_conv.is_owned = ptr_is_owned(msg);
50310 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50311 msg_conv = FundingSigned_clone(&msg_conv);
50312 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50313 *ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
50314 uint64_t ret_ref = tag_ptr(ret_copy, true);
50318 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_ready"))) TS_MessageSendEvent_send_channel_ready(int8_tArray node_id, uint64_t msg) {
50319 LDKPublicKey node_id_ref;
50320 CHECK(node_id->arr_len == 33);
50321 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50322 LDKChannelReady msg_conv;
50323 msg_conv.inner = untag_ptr(msg);
50324 msg_conv.is_owned = ptr_is_owned(msg);
50325 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50326 msg_conv = ChannelReady_clone(&msg_conv);
50327 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50328 *ret_copy = MessageSendEvent_send_channel_ready(node_id_ref, msg_conv);
50329 uint64_t ret_ref = tag_ptr(ret_copy, true);
50333 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_announcement_signatures"))) TS_MessageSendEvent_send_announcement_signatures(int8_tArray node_id, uint64_t msg) {
50334 LDKPublicKey node_id_ref;
50335 CHECK(node_id->arr_len == 33);
50336 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50337 LDKAnnouncementSignatures msg_conv;
50338 msg_conv.inner = untag_ptr(msg);
50339 msg_conv.is_owned = ptr_is_owned(msg);
50340 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50341 msg_conv = AnnouncementSignatures_clone(&msg_conv);
50342 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50343 *ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
50344 uint64_t ret_ref = tag_ptr(ret_copy, true);
50348 uint64_t __attribute__((export_name("TS_MessageSendEvent_update_htlcs"))) TS_MessageSendEvent_update_htlcs(int8_tArray node_id, uint64_t updates) {
50349 LDKPublicKey node_id_ref;
50350 CHECK(node_id->arr_len == 33);
50351 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50352 LDKCommitmentUpdate updates_conv;
50353 updates_conv.inner = untag_ptr(updates);
50354 updates_conv.is_owned = ptr_is_owned(updates);
50355 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
50356 updates_conv = CommitmentUpdate_clone(&updates_conv);
50357 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50358 *ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
50359 uint64_t ret_ref = tag_ptr(ret_copy, true);
50363 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_revoke_and_ack"))) TS_MessageSendEvent_send_revoke_and_ack(int8_tArray node_id, uint64_t msg) {
50364 LDKPublicKey node_id_ref;
50365 CHECK(node_id->arr_len == 33);
50366 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50367 LDKRevokeAndACK msg_conv;
50368 msg_conv.inner = untag_ptr(msg);
50369 msg_conv.is_owned = ptr_is_owned(msg);
50370 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50371 msg_conv = RevokeAndACK_clone(&msg_conv);
50372 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50373 *ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
50374 uint64_t ret_ref = tag_ptr(ret_copy, true);
50378 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_closing_signed"))) TS_MessageSendEvent_send_closing_signed(int8_tArray node_id, uint64_t msg) {
50379 LDKPublicKey node_id_ref;
50380 CHECK(node_id->arr_len == 33);
50381 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50382 LDKClosingSigned msg_conv;
50383 msg_conv.inner = untag_ptr(msg);
50384 msg_conv.is_owned = ptr_is_owned(msg);
50385 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50386 msg_conv = ClosingSigned_clone(&msg_conv);
50387 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50388 *ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
50389 uint64_t ret_ref = tag_ptr(ret_copy, true);
50393 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_shutdown"))) TS_MessageSendEvent_send_shutdown(int8_tArray node_id, uint64_t msg) {
50394 LDKPublicKey node_id_ref;
50395 CHECK(node_id->arr_len == 33);
50396 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50397 LDKShutdown msg_conv;
50398 msg_conv.inner = untag_ptr(msg);
50399 msg_conv.is_owned = ptr_is_owned(msg);
50400 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50401 msg_conv = Shutdown_clone(&msg_conv);
50402 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50403 *ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
50404 uint64_t ret_ref = tag_ptr(ret_copy, true);
50408 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_reestablish"))) TS_MessageSendEvent_send_channel_reestablish(int8_tArray node_id, uint64_t msg) {
50409 LDKPublicKey node_id_ref;
50410 CHECK(node_id->arr_len == 33);
50411 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50412 LDKChannelReestablish msg_conv;
50413 msg_conv.inner = untag_ptr(msg);
50414 msg_conv.is_owned = ptr_is_owned(msg);
50415 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50416 msg_conv = ChannelReestablish_clone(&msg_conv);
50417 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50418 *ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
50419 uint64_t ret_ref = tag_ptr(ret_copy, true);
50423 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) {
50424 LDKPublicKey node_id_ref;
50425 CHECK(node_id->arr_len == 33);
50426 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50427 LDKChannelAnnouncement msg_conv;
50428 msg_conv.inner = untag_ptr(msg);
50429 msg_conv.is_owned = ptr_is_owned(msg);
50430 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50431 msg_conv = ChannelAnnouncement_clone(&msg_conv);
50432 LDKChannelUpdate update_msg_conv;
50433 update_msg_conv.inner = untag_ptr(update_msg);
50434 update_msg_conv.is_owned = ptr_is_owned(update_msg);
50435 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
50436 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
50437 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50438 *ret_copy = MessageSendEvent_send_channel_announcement(node_id_ref, msg_conv, update_msg_conv);
50439 uint64_t ret_ref = tag_ptr(ret_copy, true);
50443 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_announcement"))) TS_MessageSendEvent_broadcast_channel_announcement(uint64_t msg, uint64_t update_msg) {
50444 LDKChannelAnnouncement msg_conv;
50445 msg_conv.inner = untag_ptr(msg);
50446 msg_conv.is_owned = ptr_is_owned(msg);
50447 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50448 msg_conv = ChannelAnnouncement_clone(&msg_conv);
50449 LDKChannelUpdate update_msg_conv;
50450 update_msg_conv.inner = untag_ptr(update_msg);
50451 update_msg_conv.is_owned = ptr_is_owned(update_msg);
50452 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
50453 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
50454 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50455 *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
50456 uint64_t ret_ref = tag_ptr(ret_copy, true);
50460 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_update"))) TS_MessageSendEvent_broadcast_channel_update(uint64_t msg) {
50461 LDKChannelUpdate msg_conv;
50462 msg_conv.inner = untag_ptr(msg);
50463 msg_conv.is_owned = ptr_is_owned(msg);
50464 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50465 msg_conv = ChannelUpdate_clone(&msg_conv);
50466 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50467 *ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
50468 uint64_t ret_ref = tag_ptr(ret_copy, true);
50472 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_node_announcement"))) TS_MessageSendEvent_broadcast_node_announcement(uint64_t msg) {
50473 LDKNodeAnnouncement msg_conv;
50474 msg_conv.inner = untag_ptr(msg);
50475 msg_conv.is_owned = ptr_is_owned(msg);
50476 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50477 msg_conv = NodeAnnouncement_clone(&msg_conv);
50478 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50479 *ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
50480 uint64_t ret_ref = tag_ptr(ret_copy, true);
50484 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_update"))) TS_MessageSendEvent_send_channel_update(int8_tArray node_id, uint64_t msg) {
50485 LDKPublicKey node_id_ref;
50486 CHECK(node_id->arr_len == 33);
50487 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50488 LDKChannelUpdate msg_conv;
50489 msg_conv.inner = untag_ptr(msg);
50490 msg_conv.is_owned = ptr_is_owned(msg);
50491 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50492 msg_conv = ChannelUpdate_clone(&msg_conv);
50493 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50494 *ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
50495 uint64_t ret_ref = tag_ptr(ret_copy, true);
50499 uint64_t __attribute__((export_name("TS_MessageSendEvent_handle_error"))) TS_MessageSendEvent_handle_error(int8_tArray node_id, uint64_t action) {
50500 LDKPublicKey node_id_ref;
50501 CHECK(node_id->arr_len == 33);
50502 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50503 void* action_ptr = untag_ptr(action);
50504 CHECK_ACCESS(action_ptr);
50505 LDKErrorAction action_conv = *(LDKErrorAction*)(action_ptr);
50506 action_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action));
50507 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50508 *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv);
50509 uint64_t ret_ref = tag_ptr(ret_copy, true);
50513 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_range_query"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint64_t msg) {
50514 LDKPublicKey node_id_ref;
50515 CHECK(node_id->arr_len == 33);
50516 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50517 LDKQueryChannelRange msg_conv;
50518 msg_conv.inner = untag_ptr(msg);
50519 msg_conv.is_owned = ptr_is_owned(msg);
50520 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50521 msg_conv = QueryChannelRange_clone(&msg_conv);
50522 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50523 *ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
50524 uint64_t ret_ref = tag_ptr(ret_copy, true);
50528 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_short_ids_query"))) TS_MessageSendEvent_send_short_ids_query(int8_tArray node_id, uint64_t msg) {
50529 LDKPublicKey node_id_ref;
50530 CHECK(node_id->arr_len == 33);
50531 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50532 LDKQueryShortChannelIds msg_conv;
50533 msg_conv.inner = untag_ptr(msg);
50534 msg_conv.is_owned = ptr_is_owned(msg);
50535 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50536 msg_conv = QueryShortChannelIds_clone(&msg_conv);
50537 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50538 *ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
50539 uint64_t ret_ref = tag_ptr(ret_copy, true);
50543 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_reply_channel_range"))) TS_MessageSendEvent_send_reply_channel_range(int8_tArray node_id, uint64_t msg) {
50544 LDKPublicKey node_id_ref;
50545 CHECK(node_id->arr_len == 33);
50546 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50547 LDKReplyChannelRange msg_conv;
50548 msg_conv.inner = untag_ptr(msg);
50549 msg_conv.is_owned = ptr_is_owned(msg);
50550 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50551 msg_conv = ReplyChannelRange_clone(&msg_conv);
50552 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50553 *ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
50554 uint64_t ret_ref = tag_ptr(ret_copy, true);
50558 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_gossip_timestamp_filter"))) TS_MessageSendEvent_send_gossip_timestamp_filter(int8_tArray node_id, uint64_t msg) {
50559 LDKPublicKey node_id_ref;
50560 CHECK(node_id->arr_len == 33);
50561 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
50562 LDKGossipTimestampFilter msg_conv;
50563 msg_conv.inner = untag_ptr(msg);
50564 msg_conv.is_owned = ptr_is_owned(msg);
50565 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
50566 msg_conv = GossipTimestampFilter_clone(&msg_conv);
50567 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
50568 *ret_copy = MessageSendEvent_send_gossip_timestamp_filter(node_id_ref, msg_conv);
50569 uint64_t ret_ref = tag_ptr(ret_copy, true);
50573 void __attribute__((export_name("TS_MessageSendEventsProvider_free"))) TS_MessageSendEventsProvider_free(uint64_t this_ptr) {
50574 if (!ptr_is_owned(this_ptr)) return;
50575 void* this_ptr_ptr = untag_ptr(this_ptr);
50576 CHECK_ACCESS(this_ptr_ptr);
50577 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(this_ptr_ptr);
50578 FREE(untag_ptr(this_ptr));
50579 MessageSendEventsProvider_free(this_ptr_conv);
50582 void __attribute__((export_name("TS_OnionMessageProvider_free"))) TS_OnionMessageProvider_free(uint64_t this_ptr) {
50583 if (!ptr_is_owned(this_ptr)) return;
50584 void* this_ptr_ptr = untag_ptr(this_ptr);
50585 CHECK_ACCESS(this_ptr_ptr);
50586 LDKOnionMessageProvider this_ptr_conv = *(LDKOnionMessageProvider*)(this_ptr_ptr);
50587 FREE(untag_ptr(this_ptr));
50588 OnionMessageProvider_free(this_ptr_conv);
50591 void __attribute__((export_name("TS_EventsProvider_free"))) TS_EventsProvider_free(uint64_t this_ptr) {
50592 if (!ptr_is_owned(this_ptr)) return;
50593 void* this_ptr_ptr = untag_ptr(this_ptr);
50594 CHECK_ACCESS(this_ptr_ptr);
50595 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(this_ptr_ptr);
50596 FREE(untag_ptr(this_ptr));
50597 EventsProvider_free(this_ptr_conv);
50600 void __attribute__((export_name("TS_EventHandler_free"))) TS_EventHandler_free(uint64_t this_ptr) {
50601 if (!ptr_is_owned(this_ptr)) return;
50602 void* this_ptr_ptr = untag_ptr(this_ptr);
50603 CHECK_ACCESS(this_ptr_ptr);
50604 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(this_ptr_ptr);
50605 FREE(untag_ptr(this_ptr));
50606 EventHandler_free(this_ptr_conv);
50609 void __attribute__((export_name("TS_GossipSync_free"))) TS_GossipSync_free(uint64_t this_ptr) {
50610 if (!ptr_is_owned(this_ptr)) return;
50611 void* this_ptr_ptr = untag_ptr(this_ptr);
50612 CHECK_ACCESS(this_ptr_ptr);
50613 LDKGossipSync this_ptr_conv = *(LDKGossipSync*)(this_ptr_ptr);
50614 FREE(untag_ptr(this_ptr));
50615 GossipSync_free(this_ptr_conv);
50618 uint64_t __attribute__((export_name("TS_GossipSync_p2_p"))) TS_GossipSync_p2_p(uint64_t a) {
50619 LDKP2PGossipSync a_conv;
50620 a_conv.inner = untag_ptr(a);
50621 a_conv.is_owned = ptr_is_owned(a);
50622 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50623 a_conv.is_owned = false;
50624 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
50625 *ret_copy = GossipSync_p2_p(&a_conv);
50626 uint64_t ret_ref = tag_ptr(ret_copy, true);
50630 uint64_t __attribute__((export_name("TS_GossipSync_rapid"))) TS_GossipSync_rapid(uint64_t a) {
50631 LDKRapidGossipSync a_conv;
50632 a_conv.inner = untag_ptr(a);
50633 a_conv.is_owned = ptr_is_owned(a);
50634 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50635 a_conv.is_owned = false;
50636 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
50637 *ret_copy = GossipSync_rapid(&a_conv);
50638 uint64_t ret_ref = tag_ptr(ret_copy, true);
50642 uint64_t __attribute__((export_name("TS_GossipSync_none"))) TS_GossipSync_none() {
50643 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
50644 *ret_copy = GossipSync_none();
50645 uint64_t ret_ref = tag_ptr(ret_copy, true);
50649 void __attribute__((export_name("TS_RapidGossipSync_free"))) TS_RapidGossipSync_free(uint64_t this_obj) {
50650 LDKRapidGossipSync this_obj_conv;
50651 this_obj_conv.inner = untag_ptr(this_obj);
50652 this_obj_conv.is_owned = ptr_is_owned(this_obj);
50653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
50654 RapidGossipSync_free(this_obj_conv);
50657 uint64_t __attribute__((export_name("TS_RapidGossipSync_new"))) TS_RapidGossipSync_new(uint64_t network_graph, uint64_t logger) {
50658 LDKNetworkGraph network_graph_conv;
50659 network_graph_conv.inner = untag_ptr(network_graph);
50660 network_graph_conv.is_owned = ptr_is_owned(network_graph);
50661 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
50662 network_graph_conv.is_owned = false;
50663 void* logger_ptr = untag_ptr(logger);
50664 CHECK_ACCESS(logger_ptr);
50665 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
50666 if (logger_conv.free == LDKLogger_JCalls_free) {
50667 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
50668 LDKLogger_JCalls_cloned(&logger_conv);
50670 LDKRapidGossipSync ret_var = RapidGossipSync_new(&network_graph_conv, logger_conv);
50671 uint64_t ret_ref = 0;
50672 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
50673 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
50677 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) {
50678 LDKRapidGossipSync this_arg_conv;
50679 this_arg_conv.inner = untag_ptr(this_arg);
50680 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50681 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50682 this_arg_conv.is_owned = false;
50683 LDKu8slice update_data_ref;
50684 update_data_ref.datalen = update_data->arr_len;
50685 update_data_ref.data = update_data->elems;
50686 void* current_time_unix_ptr = untag_ptr(current_time_unix);
50687 CHECK_ACCESS(current_time_unix_ptr);
50688 LDKCOption_u64Z current_time_unix_conv = *(LDKCOption_u64Z*)(current_time_unix_ptr);
50689 current_time_unix_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(current_time_unix));
50690 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
50691 *ret_conv = RapidGossipSync_update_network_graph_no_std(&this_arg_conv, update_data_ref, current_time_unix_conv);
50693 return tag_ptr(ret_conv, true);
50696 jboolean __attribute__((export_name("TS_RapidGossipSync_is_initial_sync_complete"))) TS_RapidGossipSync_is_initial_sync_complete(uint64_t this_arg) {
50697 LDKRapidGossipSync this_arg_conv;
50698 this_arg_conv.inner = untag_ptr(this_arg);
50699 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50700 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50701 this_arg_conv.is_owned = false;
50702 jboolean ret_conv = RapidGossipSync_is_initial_sync_complete(&this_arg_conv);
50706 void __attribute__((export_name("TS_GraphSyncError_free"))) TS_GraphSyncError_free(uint64_t this_ptr) {
50707 if (!ptr_is_owned(this_ptr)) return;
50708 void* this_ptr_ptr = untag_ptr(this_ptr);
50709 CHECK_ACCESS(this_ptr_ptr);
50710 LDKGraphSyncError this_ptr_conv = *(LDKGraphSyncError*)(this_ptr_ptr);
50711 FREE(untag_ptr(this_ptr));
50712 GraphSyncError_free(this_ptr_conv);
50715 static inline uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg) {
50716 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50717 *ret_copy = GraphSyncError_clone(arg);
50718 uint64_t ret_ref = tag_ptr(ret_copy, true);
50721 int64_t __attribute__((export_name("TS_GraphSyncError_clone_ptr"))) TS_GraphSyncError_clone_ptr(uint64_t arg) {
50722 LDKGraphSyncError* arg_conv = (LDKGraphSyncError*)untag_ptr(arg);
50723 int64_t ret_conv = GraphSyncError_clone_ptr(arg_conv);
50727 uint64_t __attribute__((export_name("TS_GraphSyncError_clone"))) TS_GraphSyncError_clone(uint64_t orig) {
50728 LDKGraphSyncError* orig_conv = (LDKGraphSyncError*)untag_ptr(orig);
50729 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50730 *ret_copy = GraphSyncError_clone(orig_conv);
50731 uint64_t ret_ref = tag_ptr(ret_copy, true);
50735 uint64_t __attribute__((export_name("TS_GraphSyncError_decode_error"))) TS_GraphSyncError_decode_error(uint64_t a) {
50736 void* a_ptr = untag_ptr(a);
50737 CHECK_ACCESS(a_ptr);
50738 LDKDecodeError a_conv = *(LDKDecodeError*)(a_ptr);
50739 a_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(a));
50740 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50741 *ret_copy = GraphSyncError_decode_error(a_conv);
50742 uint64_t ret_ref = tag_ptr(ret_copy, true);
50746 uint64_t __attribute__((export_name("TS_GraphSyncError_lightning_error"))) TS_GraphSyncError_lightning_error(uint64_t a) {
50747 LDKLightningError a_conv;
50748 a_conv.inner = untag_ptr(a);
50749 a_conv.is_owned = ptr_is_owned(a);
50750 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50751 a_conv = LightningError_clone(&a_conv);
50752 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
50753 *ret_copy = GraphSyncError_lightning_error(a_conv);
50754 uint64_t ret_ref = tag_ptr(ret_copy, true);
50758 void __attribute__((export_name("TS_ParseError_free"))) TS_ParseError_free(uint64_t this_ptr) {
50759 if (!ptr_is_owned(this_ptr)) return;
50760 void* this_ptr_ptr = untag_ptr(this_ptr);
50761 CHECK_ACCESS(this_ptr_ptr);
50762 LDKParseError this_ptr_conv = *(LDKParseError*)(this_ptr_ptr);
50763 FREE(untag_ptr(this_ptr));
50764 ParseError_free(this_ptr_conv);
50767 static inline uint64_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg) {
50768 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50769 *ret_copy = ParseError_clone(arg);
50770 uint64_t ret_ref = tag_ptr(ret_copy, true);
50773 int64_t __attribute__((export_name("TS_ParseError_clone_ptr"))) TS_ParseError_clone_ptr(uint64_t arg) {
50774 LDKParseError* arg_conv = (LDKParseError*)untag_ptr(arg);
50775 int64_t ret_conv = ParseError_clone_ptr(arg_conv);
50779 uint64_t __attribute__((export_name("TS_ParseError_clone"))) TS_ParseError_clone(uint64_t orig) {
50780 LDKParseError* orig_conv = (LDKParseError*)untag_ptr(orig);
50781 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50782 *ret_copy = ParseError_clone(orig_conv);
50783 uint64_t ret_ref = tag_ptr(ret_copy, true);
50787 uint64_t __attribute__((export_name("TS_ParseError_bech32_error"))) TS_ParseError_bech32_error(uint64_t a) {
50788 void* a_ptr = untag_ptr(a);
50789 CHECK_ACCESS(a_ptr);
50790 LDKBech32Error a_conv = *(LDKBech32Error*)(a_ptr);
50791 a_conv = Bech32Error_clone((LDKBech32Error*)untag_ptr(a));
50792 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50793 *ret_copy = ParseError_bech32_error(a_conv);
50794 uint64_t ret_ref = tag_ptr(ret_copy, true);
50798 uint64_t __attribute__((export_name("TS_ParseError_parse_amount_error"))) TS_ParseError_parse_amount_error(int32_t a) {
50800 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50801 *ret_copy = ParseError_parse_amount_error((LDKError){ ._dummy = 0 });
50802 uint64_t ret_ref = tag_ptr(ret_copy, true);
50806 uint64_t __attribute__((export_name("TS_ParseError_malformed_signature"))) TS_ParseError_malformed_signature(uint32_t a) {
50807 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
50808 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50809 *ret_copy = ParseError_malformed_signature(a_conv);
50810 uint64_t ret_ref = tag_ptr(ret_copy, true);
50814 uint64_t __attribute__((export_name("TS_ParseError_bad_prefix"))) TS_ParseError_bad_prefix() {
50815 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50816 *ret_copy = ParseError_bad_prefix();
50817 uint64_t ret_ref = tag_ptr(ret_copy, true);
50821 uint64_t __attribute__((export_name("TS_ParseError_unknown_currency"))) TS_ParseError_unknown_currency() {
50822 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50823 *ret_copy = ParseError_unknown_currency();
50824 uint64_t ret_ref = tag_ptr(ret_copy, true);
50828 uint64_t __attribute__((export_name("TS_ParseError_unknown_si_prefix"))) TS_ParseError_unknown_si_prefix() {
50829 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50830 *ret_copy = ParseError_unknown_si_prefix();
50831 uint64_t ret_ref = tag_ptr(ret_copy, true);
50835 uint64_t __attribute__((export_name("TS_ParseError_malformed_hrp"))) TS_ParseError_malformed_hrp() {
50836 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50837 *ret_copy = ParseError_malformed_hrp();
50838 uint64_t ret_ref = tag_ptr(ret_copy, true);
50842 uint64_t __attribute__((export_name("TS_ParseError_too_short_data_part"))) TS_ParseError_too_short_data_part() {
50843 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50844 *ret_copy = ParseError_too_short_data_part();
50845 uint64_t ret_ref = tag_ptr(ret_copy, true);
50849 uint64_t __attribute__((export_name("TS_ParseError_unexpected_end_of_tagged_fields"))) TS_ParseError_unexpected_end_of_tagged_fields() {
50850 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50851 *ret_copy = ParseError_unexpected_end_of_tagged_fields();
50852 uint64_t ret_ref = tag_ptr(ret_copy, true);
50856 uint64_t __attribute__((export_name("TS_ParseError_description_decode_error"))) TS_ParseError_description_decode_error(int32_t a) {
50858 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50859 *ret_copy = ParseError_description_decode_error((LDKError){ ._dummy = 0 });
50860 uint64_t ret_ref = tag_ptr(ret_copy, true);
50864 uint64_t __attribute__((export_name("TS_ParseError_padding_error"))) TS_ParseError_padding_error() {
50865 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50866 *ret_copy = ParseError_padding_error();
50867 uint64_t ret_ref = tag_ptr(ret_copy, true);
50871 uint64_t __attribute__((export_name("TS_ParseError_integer_overflow_error"))) TS_ParseError_integer_overflow_error() {
50872 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50873 *ret_copy = ParseError_integer_overflow_error();
50874 uint64_t ret_ref = tag_ptr(ret_copy, true);
50878 uint64_t __attribute__((export_name("TS_ParseError_invalid_seg_wit_program_length"))) TS_ParseError_invalid_seg_wit_program_length() {
50879 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50880 *ret_copy = ParseError_invalid_seg_wit_program_length();
50881 uint64_t ret_ref = tag_ptr(ret_copy, true);
50885 uint64_t __attribute__((export_name("TS_ParseError_invalid_pub_key_hash_length"))) TS_ParseError_invalid_pub_key_hash_length() {
50886 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50887 *ret_copy = ParseError_invalid_pub_key_hash_length();
50888 uint64_t ret_ref = tag_ptr(ret_copy, true);
50892 uint64_t __attribute__((export_name("TS_ParseError_invalid_script_hash_length"))) TS_ParseError_invalid_script_hash_length() {
50893 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50894 *ret_copy = ParseError_invalid_script_hash_length();
50895 uint64_t ret_ref = tag_ptr(ret_copy, true);
50899 uint64_t __attribute__((export_name("TS_ParseError_invalid_recovery_id"))) TS_ParseError_invalid_recovery_id() {
50900 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50901 *ret_copy = ParseError_invalid_recovery_id();
50902 uint64_t ret_ref = tag_ptr(ret_copy, true);
50906 uint64_t __attribute__((export_name("TS_ParseError_invalid_slice_length"))) TS_ParseError_invalid_slice_length(jstring a) {
50907 LDKStr a_conv = str_ref_to_owned_c(a);
50908 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50909 *ret_copy = ParseError_invalid_slice_length(a_conv);
50910 uint64_t ret_ref = tag_ptr(ret_copy, true);
50914 uint64_t __attribute__((export_name("TS_ParseError_skip"))) TS_ParseError_skip() {
50915 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
50916 *ret_copy = ParseError_skip();
50917 uint64_t ret_ref = tag_ptr(ret_copy, true);
50921 jboolean __attribute__((export_name("TS_ParseError_eq"))) TS_ParseError_eq(uint64_t a, uint64_t b) {
50922 LDKParseError* a_conv = (LDKParseError*)untag_ptr(a);
50923 LDKParseError* b_conv = (LDKParseError*)untag_ptr(b);
50924 jboolean ret_conv = ParseError_eq(a_conv, b_conv);
50928 void __attribute__((export_name("TS_ParseOrSemanticError_free"))) TS_ParseOrSemanticError_free(uint64_t this_ptr) {
50929 if (!ptr_is_owned(this_ptr)) return;
50930 void* this_ptr_ptr = untag_ptr(this_ptr);
50931 CHECK_ACCESS(this_ptr_ptr);
50932 LDKParseOrSemanticError this_ptr_conv = *(LDKParseOrSemanticError*)(this_ptr_ptr);
50933 FREE(untag_ptr(this_ptr));
50934 ParseOrSemanticError_free(this_ptr_conv);
50937 static inline uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg) {
50938 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50939 *ret_copy = ParseOrSemanticError_clone(arg);
50940 uint64_t ret_ref = tag_ptr(ret_copy, true);
50943 int64_t __attribute__((export_name("TS_ParseOrSemanticError_clone_ptr"))) TS_ParseOrSemanticError_clone_ptr(uint64_t arg) {
50944 LDKParseOrSemanticError* arg_conv = (LDKParseOrSemanticError*)untag_ptr(arg);
50945 int64_t ret_conv = ParseOrSemanticError_clone_ptr(arg_conv);
50949 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_clone"))) TS_ParseOrSemanticError_clone(uint64_t orig) {
50950 LDKParseOrSemanticError* orig_conv = (LDKParseOrSemanticError*)untag_ptr(orig);
50951 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50952 *ret_copy = ParseOrSemanticError_clone(orig_conv);
50953 uint64_t ret_ref = tag_ptr(ret_copy, true);
50957 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_parse_error"))) TS_ParseOrSemanticError_parse_error(uint64_t a) {
50958 void* a_ptr = untag_ptr(a);
50959 CHECK_ACCESS(a_ptr);
50960 LDKParseError a_conv = *(LDKParseError*)(a_ptr);
50961 a_conv = ParseError_clone((LDKParseError*)untag_ptr(a));
50962 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50963 *ret_copy = ParseOrSemanticError_parse_error(a_conv);
50964 uint64_t ret_ref = tag_ptr(ret_copy, true);
50968 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_semantic_error"))) TS_ParseOrSemanticError_semantic_error(uint32_t a) {
50969 LDKSemanticError a_conv = LDKSemanticError_from_js(a);
50970 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
50971 *ret_copy = ParseOrSemanticError_semantic_error(a_conv);
50972 uint64_t ret_ref = tag_ptr(ret_copy, true);
50976 jboolean __attribute__((export_name("TS_ParseOrSemanticError_eq"))) TS_ParseOrSemanticError_eq(uint64_t a, uint64_t b) {
50977 LDKParseOrSemanticError* a_conv = (LDKParseOrSemanticError*)untag_ptr(a);
50978 LDKParseOrSemanticError* b_conv = (LDKParseOrSemanticError*)untag_ptr(b);
50979 jboolean ret_conv = ParseOrSemanticError_eq(a_conv, b_conv);
50983 void __attribute__((export_name("TS_Invoice_free"))) TS_Invoice_free(uint64_t this_obj) {
50984 LDKInvoice this_obj_conv;
50985 this_obj_conv.inner = untag_ptr(this_obj);
50986 this_obj_conv.is_owned = ptr_is_owned(this_obj);
50987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
50988 Invoice_free(this_obj_conv);
50991 jboolean __attribute__((export_name("TS_Invoice_eq"))) TS_Invoice_eq(uint64_t a, uint64_t b) {
50993 a_conv.inner = untag_ptr(a);
50994 a_conv.is_owned = ptr_is_owned(a);
50995 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
50996 a_conv.is_owned = false;
50998 b_conv.inner = untag_ptr(b);
50999 b_conv.is_owned = ptr_is_owned(b);
51000 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51001 b_conv.is_owned = false;
51002 jboolean ret_conv = Invoice_eq(&a_conv, &b_conv);
51006 static inline uint64_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
51007 LDKInvoice ret_var = Invoice_clone(arg);
51008 uint64_t ret_ref = 0;
51009 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51010 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51013 int64_t __attribute__((export_name("TS_Invoice_clone_ptr"))) TS_Invoice_clone_ptr(uint64_t arg) {
51014 LDKInvoice arg_conv;
51015 arg_conv.inner = untag_ptr(arg);
51016 arg_conv.is_owned = ptr_is_owned(arg);
51017 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51018 arg_conv.is_owned = false;
51019 int64_t ret_conv = Invoice_clone_ptr(&arg_conv);
51023 uint64_t __attribute__((export_name("TS_Invoice_clone"))) TS_Invoice_clone(uint64_t orig) {
51024 LDKInvoice orig_conv;
51025 orig_conv.inner = untag_ptr(orig);
51026 orig_conv.is_owned = ptr_is_owned(orig);
51027 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51028 orig_conv.is_owned = false;
51029 LDKInvoice ret_var = Invoice_clone(&orig_conv);
51030 uint64_t ret_ref = 0;
51031 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51032 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51036 int64_t __attribute__((export_name("TS_Invoice_hash"))) TS_Invoice_hash(uint64_t o) {
51038 o_conv.inner = untag_ptr(o);
51039 o_conv.is_owned = ptr_is_owned(o);
51040 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51041 o_conv.is_owned = false;
51042 int64_t ret_conv = Invoice_hash(&o_conv);
51046 void __attribute__((export_name("TS_SignedRawInvoice_free"))) TS_SignedRawInvoice_free(uint64_t this_obj) {
51047 LDKSignedRawInvoice this_obj_conv;
51048 this_obj_conv.inner = untag_ptr(this_obj);
51049 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51050 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51051 SignedRawInvoice_free(this_obj_conv);
51054 jboolean __attribute__((export_name("TS_SignedRawInvoice_eq"))) TS_SignedRawInvoice_eq(uint64_t a, uint64_t b) {
51055 LDKSignedRawInvoice a_conv;
51056 a_conv.inner = untag_ptr(a);
51057 a_conv.is_owned = ptr_is_owned(a);
51058 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51059 a_conv.is_owned = false;
51060 LDKSignedRawInvoice b_conv;
51061 b_conv.inner = untag_ptr(b);
51062 b_conv.is_owned = ptr_is_owned(b);
51063 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51064 b_conv.is_owned = false;
51065 jboolean ret_conv = SignedRawInvoice_eq(&a_conv, &b_conv);
51069 static inline uint64_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
51070 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
51071 uint64_t ret_ref = 0;
51072 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51073 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51076 int64_t __attribute__((export_name("TS_SignedRawInvoice_clone_ptr"))) TS_SignedRawInvoice_clone_ptr(uint64_t arg) {
51077 LDKSignedRawInvoice arg_conv;
51078 arg_conv.inner = untag_ptr(arg);
51079 arg_conv.is_owned = ptr_is_owned(arg);
51080 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51081 arg_conv.is_owned = false;
51082 int64_t ret_conv = SignedRawInvoice_clone_ptr(&arg_conv);
51086 uint64_t __attribute__((export_name("TS_SignedRawInvoice_clone"))) TS_SignedRawInvoice_clone(uint64_t orig) {
51087 LDKSignedRawInvoice orig_conv;
51088 orig_conv.inner = untag_ptr(orig);
51089 orig_conv.is_owned = ptr_is_owned(orig);
51090 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51091 orig_conv.is_owned = false;
51092 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
51093 uint64_t ret_ref = 0;
51094 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51095 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51099 int64_t __attribute__((export_name("TS_SignedRawInvoice_hash"))) TS_SignedRawInvoice_hash(uint64_t o) {
51100 LDKSignedRawInvoice o_conv;
51101 o_conv.inner = untag_ptr(o);
51102 o_conv.is_owned = ptr_is_owned(o);
51103 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51104 o_conv.is_owned = false;
51105 int64_t ret_conv = SignedRawInvoice_hash(&o_conv);
51109 void __attribute__((export_name("TS_RawInvoice_free"))) TS_RawInvoice_free(uint64_t this_obj) {
51110 LDKRawInvoice this_obj_conv;
51111 this_obj_conv.inner = untag_ptr(this_obj);
51112 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51113 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51114 RawInvoice_free(this_obj_conv);
51117 uint64_t __attribute__((export_name("TS_RawInvoice_get_data"))) TS_RawInvoice_get_data(uint64_t this_ptr) {
51118 LDKRawInvoice this_ptr_conv;
51119 this_ptr_conv.inner = untag_ptr(this_ptr);
51120 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51122 this_ptr_conv.is_owned = false;
51123 LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
51124 uint64_t ret_ref = 0;
51125 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51126 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51130 void __attribute__((export_name("TS_RawInvoice_set_data"))) TS_RawInvoice_set_data(uint64_t this_ptr, uint64_t val) {
51131 LDKRawInvoice this_ptr_conv;
51132 this_ptr_conv.inner = untag_ptr(this_ptr);
51133 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51134 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51135 this_ptr_conv.is_owned = false;
51136 LDKRawDataPart val_conv;
51137 val_conv.inner = untag_ptr(val);
51138 val_conv.is_owned = ptr_is_owned(val);
51139 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
51140 val_conv = RawDataPart_clone(&val_conv);
51141 RawInvoice_set_data(&this_ptr_conv, val_conv);
51144 jboolean __attribute__((export_name("TS_RawInvoice_eq"))) TS_RawInvoice_eq(uint64_t a, uint64_t b) {
51145 LDKRawInvoice a_conv;
51146 a_conv.inner = untag_ptr(a);
51147 a_conv.is_owned = ptr_is_owned(a);
51148 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51149 a_conv.is_owned = false;
51150 LDKRawInvoice b_conv;
51151 b_conv.inner = untag_ptr(b);
51152 b_conv.is_owned = ptr_is_owned(b);
51153 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51154 b_conv.is_owned = false;
51155 jboolean ret_conv = RawInvoice_eq(&a_conv, &b_conv);
51159 static inline uint64_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
51160 LDKRawInvoice ret_var = RawInvoice_clone(arg);
51161 uint64_t ret_ref = 0;
51162 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51163 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51166 int64_t __attribute__((export_name("TS_RawInvoice_clone_ptr"))) TS_RawInvoice_clone_ptr(uint64_t arg) {
51167 LDKRawInvoice arg_conv;
51168 arg_conv.inner = untag_ptr(arg);
51169 arg_conv.is_owned = ptr_is_owned(arg);
51170 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51171 arg_conv.is_owned = false;
51172 int64_t ret_conv = RawInvoice_clone_ptr(&arg_conv);
51176 uint64_t __attribute__((export_name("TS_RawInvoice_clone"))) TS_RawInvoice_clone(uint64_t orig) {
51177 LDKRawInvoice orig_conv;
51178 orig_conv.inner = untag_ptr(orig);
51179 orig_conv.is_owned = ptr_is_owned(orig);
51180 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51181 orig_conv.is_owned = false;
51182 LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
51183 uint64_t ret_ref = 0;
51184 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51185 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51189 int64_t __attribute__((export_name("TS_RawInvoice_hash"))) TS_RawInvoice_hash(uint64_t o) {
51190 LDKRawInvoice o_conv;
51191 o_conv.inner = untag_ptr(o);
51192 o_conv.is_owned = ptr_is_owned(o);
51193 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51194 o_conv.is_owned = false;
51195 int64_t ret_conv = RawInvoice_hash(&o_conv);
51199 void __attribute__((export_name("TS_RawDataPart_free"))) TS_RawDataPart_free(uint64_t this_obj) {
51200 LDKRawDataPart this_obj_conv;
51201 this_obj_conv.inner = untag_ptr(this_obj);
51202 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51204 RawDataPart_free(this_obj_conv);
51207 uint64_t __attribute__((export_name("TS_RawDataPart_get_timestamp"))) TS_RawDataPart_get_timestamp(uint64_t this_ptr) {
51208 LDKRawDataPart this_ptr_conv;
51209 this_ptr_conv.inner = untag_ptr(this_ptr);
51210 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51212 this_ptr_conv.is_owned = false;
51213 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
51214 uint64_t ret_ref = 0;
51215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51216 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51220 void __attribute__((export_name("TS_RawDataPart_set_timestamp"))) TS_RawDataPart_set_timestamp(uint64_t this_ptr, uint64_t val) {
51221 LDKRawDataPart this_ptr_conv;
51222 this_ptr_conv.inner = untag_ptr(this_ptr);
51223 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51225 this_ptr_conv.is_owned = false;
51226 LDKPositiveTimestamp val_conv;
51227 val_conv.inner = untag_ptr(val);
51228 val_conv.is_owned = ptr_is_owned(val);
51229 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
51230 val_conv = PositiveTimestamp_clone(&val_conv);
51231 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
51234 jboolean __attribute__((export_name("TS_RawDataPart_eq"))) TS_RawDataPart_eq(uint64_t a, uint64_t b) {
51235 LDKRawDataPart a_conv;
51236 a_conv.inner = untag_ptr(a);
51237 a_conv.is_owned = ptr_is_owned(a);
51238 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51239 a_conv.is_owned = false;
51240 LDKRawDataPart b_conv;
51241 b_conv.inner = untag_ptr(b);
51242 b_conv.is_owned = ptr_is_owned(b);
51243 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51244 b_conv.is_owned = false;
51245 jboolean ret_conv = RawDataPart_eq(&a_conv, &b_conv);
51249 static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
51250 LDKRawDataPart ret_var = RawDataPart_clone(arg);
51251 uint64_t ret_ref = 0;
51252 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51253 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51256 int64_t __attribute__((export_name("TS_RawDataPart_clone_ptr"))) TS_RawDataPart_clone_ptr(uint64_t arg) {
51257 LDKRawDataPart arg_conv;
51258 arg_conv.inner = untag_ptr(arg);
51259 arg_conv.is_owned = ptr_is_owned(arg);
51260 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51261 arg_conv.is_owned = false;
51262 int64_t ret_conv = RawDataPart_clone_ptr(&arg_conv);
51266 uint64_t __attribute__((export_name("TS_RawDataPart_clone"))) TS_RawDataPart_clone(uint64_t orig) {
51267 LDKRawDataPart orig_conv;
51268 orig_conv.inner = untag_ptr(orig);
51269 orig_conv.is_owned = ptr_is_owned(orig);
51270 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51271 orig_conv.is_owned = false;
51272 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
51273 uint64_t ret_ref = 0;
51274 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51275 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51279 int64_t __attribute__((export_name("TS_RawDataPart_hash"))) TS_RawDataPart_hash(uint64_t o) {
51280 LDKRawDataPart o_conv;
51281 o_conv.inner = untag_ptr(o);
51282 o_conv.is_owned = ptr_is_owned(o);
51283 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51284 o_conv.is_owned = false;
51285 int64_t ret_conv = RawDataPart_hash(&o_conv);
51289 void __attribute__((export_name("TS_PositiveTimestamp_free"))) TS_PositiveTimestamp_free(uint64_t this_obj) {
51290 LDKPositiveTimestamp this_obj_conv;
51291 this_obj_conv.inner = untag_ptr(this_obj);
51292 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51294 PositiveTimestamp_free(this_obj_conv);
51297 jboolean __attribute__((export_name("TS_PositiveTimestamp_eq"))) TS_PositiveTimestamp_eq(uint64_t a, uint64_t b) {
51298 LDKPositiveTimestamp a_conv;
51299 a_conv.inner = untag_ptr(a);
51300 a_conv.is_owned = ptr_is_owned(a);
51301 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51302 a_conv.is_owned = false;
51303 LDKPositiveTimestamp b_conv;
51304 b_conv.inner = untag_ptr(b);
51305 b_conv.is_owned = ptr_is_owned(b);
51306 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51307 b_conv.is_owned = false;
51308 jboolean ret_conv = PositiveTimestamp_eq(&a_conv, &b_conv);
51312 static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
51313 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
51314 uint64_t ret_ref = 0;
51315 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51316 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51319 int64_t __attribute__((export_name("TS_PositiveTimestamp_clone_ptr"))) TS_PositiveTimestamp_clone_ptr(uint64_t arg) {
51320 LDKPositiveTimestamp arg_conv;
51321 arg_conv.inner = untag_ptr(arg);
51322 arg_conv.is_owned = ptr_is_owned(arg);
51323 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51324 arg_conv.is_owned = false;
51325 int64_t ret_conv = PositiveTimestamp_clone_ptr(&arg_conv);
51329 uint64_t __attribute__((export_name("TS_PositiveTimestamp_clone"))) TS_PositiveTimestamp_clone(uint64_t orig) {
51330 LDKPositiveTimestamp orig_conv;
51331 orig_conv.inner = untag_ptr(orig);
51332 orig_conv.is_owned = ptr_is_owned(orig);
51333 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51334 orig_conv.is_owned = false;
51335 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
51336 uint64_t ret_ref = 0;
51337 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51338 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51342 int64_t __attribute__((export_name("TS_PositiveTimestamp_hash"))) TS_PositiveTimestamp_hash(uint64_t o) {
51343 LDKPositiveTimestamp o_conv;
51344 o_conv.inner = untag_ptr(o);
51345 o_conv.is_owned = ptr_is_owned(o);
51346 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51347 o_conv.is_owned = false;
51348 int64_t ret_conv = PositiveTimestamp_hash(&o_conv);
51352 uint32_t __attribute__((export_name("TS_SiPrefix_clone"))) TS_SiPrefix_clone(uint64_t orig) {
51353 LDKSiPrefix* orig_conv = (LDKSiPrefix*)untag_ptr(orig);
51354 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_clone(orig_conv));
51358 uint32_t __attribute__((export_name("TS_SiPrefix_milli"))) TS_SiPrefix_milli() {
51359 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_milli());
51363 uint32_t __attribute__((export_name("TS_SiPrefix_micro"))) TS_SiPrefix_micro() {
51364 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_micro());
51368 uint32_t __attribute__((export_name("TS_SiPrefix_nano"))) TS_SiPrefix_nano() {
51369 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_nano());
51373 uint32_t __attribute__((export_name("TS_SiPrefix_pico"))) TS_SiPrefix_pico() {
51374 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_pico());
51378 jboolean __attribute__((export_name("TS_SiPrefix_eq"))) TS_SiPrefix_eq(uint64_t a, uint64_t b) {
51379 LDKSiPrefix* a_conv = (LDKSiPrefix*)untag_ptr(a);
51380 LDKSiPrefix* b_conv = (LDKSiPrefix*)untag_ptr(b);
51381 jboolean ret_conv = SiPrefix_eq(a_conv, b_conv);
51385 int64_t __attribute__((export_name("TS_SiPrefix_hash"))) TS_SiPrefix_hash(uint64_t o) {
51386 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
51387 int64_t ret_conv = SiPrefix_hash(o_conv);
51391 int64_t __attribute__((export_name("TS_SiPrefix_multiplier"))) TS_SiPrefix_multiplier(uint64_t this_arg) {
51392 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)untag_ptr(this_arg);
51393 int64_t ret_conv = SiPrefix_multiplier(this_arg_conv);
51397 uint32_t __attribute__((export_name("TS_Currency_clone"))) TS_Currency_clone(uint64_t orig) {
51398 LDKCurrency* orig_conv = (LDKCurrency*)untag_ptr(orig);
51399 uint32_t ret_conv = LDKCurrency_to_js(Currency_clone(orig_conv));
51403 uint32_t __attribute__((export_name("TS_Currency_bitcoin"))) TS_Currency_bitcoin() {
51404 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin());
51408 uint32_t __attribute__((export_name("TS_Currency_bitcoin_testnet"))) TS_Currency_bitcoin_testnet() {
51409 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin_testnet());
51413 uint32_t __attribute__((export_name("TS_Currency_regtest"))) TS_Currency_regtest() {
51414 uint32_t ret_conv = LDKCurrency_to_js(Currency_regtest());
51418 uint32_t __attribute__((export_name("TS_Currency_simnet"))) TS_Currency_simnet() {
51419 uint32_t ret_conv = LDKCurrency_to_js(Currency_simnet());
51423 uint32_t __attribute__((export_name("TS_Currency_signet"))) TS_Currency_signet() {
51424 uint32_t ret_conv = LDKCurrency_to_js(Currency_signet());
51428 int64_t __attribute__((export_name("TS_Currency_hash"))) TS_Currency_hash(uint64_t o) {
51429 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
51430 int64_t ret_conv = Currency_hash(o_conv);
51434 jboolean __attribute__((export_name("TS_Currency_eq"))) TS_Currency_eq(uint64_t a, uint64_t b) {
51435 LDKCurrency* a_conv = (LDKCurrency*)untag_ptr(a);
51436 LDKCurrency* b_conv = (LDKCurrency*)untag_ptr(b);
51437 jboolean ret_conv = Currency_eq(a_conv, b_conv);
51441 void __attribute__((export_name("TS_Sha256_free"))) TS_Sha256_free(uint64_t this_obj) {
51442 LDKSha256 this_obj_conv;
51443 this_obj_conv.inner = untag_ptr(this_obj);
51444 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51446 Sha256_free(this_obj_conv);
51449 static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
51450 LDKSha256 ret_var = Sha256_clone(arg);
51451 uint64_t ret_ref = 0;
51452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51453 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51456 int64_t __attribute__((export_name("TS_Sha256_clone_ptr"))) TS_Sha256_clone_ptr(uint64_t arg) {
51457 LDKSha256 arg_conv;
51458 arg_conv.inner = untag_ptr(arg);
51459 arg_conv.is_owned = ptr_is_owned(arg);
51460 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51461 arg_conv.is_owned = false;
51462 int64_t ret_conv = Sha256_clone_ptr(&arg_conv);
51466 uint64_t __attribute__((export_name("TS_Sha256_clone"))) TS_Sha256_clone(uint64_t orig) {
51467 LDKSha256 orig_conv;
51468 orig_conv.inner = untag_ptr(orig);
51469 orig_conv.is_owned = ptr_is_owned(orig);
51470 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51471 orig_conv.is_owned = false;
51472 LDKSha256 ret_var = Sha256_clone(&orig_conv);
51473 uint64_t ret_ref = 0;
51474 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51475 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51479 int64_t __attribute__((export_name("TS_Sha256_hash"))) TS_Sha256_hash(uint64_t o) {
51481 o_conv.inner = untag_ptr(o);
51482 o_conv.is_owned = ptr_is_owned(o);
51483 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51484 o_conv.is_owned = false;
51485 int64_t ret_conv = Sha256_hash(&o_conv);
51489 jboolean __attribute__((export_name("TS_Sha256_eq"))) TS_Sha256_eq(uint64_t a, uint64_t b) {
51491 a_conv.inner = untag_ptr(a);
51492 a_conv.is_owned = ptr_is_owned(a);
51493 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51494 a_conv.is_owned = false;
51496 b_conv.inner = untag_ptr(b);
51497 b_conv.is_owned = ptr_is_owned(b);
51498 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51499 b_conv.is_owned = false;
51500 jboolean ret_conv = Sha256_eq(&a_conv, &b_conv);
51504 uint64_t __attribute__((export_name("TS_Sha256_from_bytes"))) TS_Sha256_from_bytes(int8_tArray bytes) {
51505 uint8_t bytes_arr[32];
51506 CHECK(bytes->arr_len == 32);
51507 memcpy(bytes_arr, bytes->elems, 32); FREE(bytes);
51508 uint8_t (*bytes_ref)[32] = &bytes_arr;
51509 LDKSha256 ret_var = Sha256_from_bytes(bytes_ref);
51510 uint64_t ret_ref = 0;
51511 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51512 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51516 void __attribute__((export_name("TS_Description_free"))) TS_Description_free(uint64_t this_obj) {
51517 LDKDescription this_obj_conv;
51518 this_obj_conv.inner = untag_ptr(this_obj);
51519 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51521 Description_free(this_obj_conv);
51524 static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
51525 LDKDescription ret_var = Description_clone(arg);
51526 uint64_t ret_ref = 0;
51527 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51528 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51531 int64_t __attribute__((export_name("TS_Description_clone_ptr"))) TS_Description_clone_ptr(uint64_t arg) {
51532 LDKDescription arg_conv;
51533 arg_conv.inner = untag_ptr(arg);
51534 arg_conv.is_owned = ptr_is_owned(arg);
51535 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51536 arg_conv.is_owned = false;
51537 int64_t ret_conv = Description_clone_ptr(&arg_conv);
51541 uint64_t __attribute__((export_name("TS_Description_clone"))) TS_Description_clone(uint64_t orig) {
51542 LDKDescription orig_conv;
51543 orig_conv.inner = untag_ptr(orig);
51544 orig_conv.is_owned = ptr_is_owned(orig);
51545 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51546 orig_conv.is_owned = false;
51547 LDKDescription ret_var = Description_clone(&orig_conv);
51548 uint64_t ret_ref = 0;
51549 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51550 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51554 int64_t __attribute__((export_name("TS_Description_hash"))) TS_Description_hash(uint64_t o) {
51555 LDKDescription o_conv;
51556 o_conv.inner = untag_ptr(o);
51557 o_conv.is_owned = ptr_is_owned(o);
51558 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51559 o_conv.is_owned = false;
51560 int64_t ret_conv = Description_hash(&o_conv);
51564 jboolean __attribute__((export_name("TS_Description_eq"))) TS_Description_eq(uint64_t a, uint64_t b) {
51565 LDKDescription a_conv;
51566 a_conv.inner = untag_ptr(a);
51567 a_conv.is_owned = ptr_is_owned(a);
51568 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51569 a_conv.is_owned = false;
51570 LDKDescription b_conv;
51571 b_conv.inner = untag_ptr(b);
51572 b_conv.is_owned = ptr_is_owned(b);
51573 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51574 b_conv.is_owned = false;
51575 jboolean ret_conv = Description_eq(&a_conv, &b_conv);
51579 void __attribute__((export_name("TS_PayeePubKey_free"))) TS_PayeePubKey_free(uint64_t this_obj) {
51580 LDKPayeePubKey this_obj_conv;
51581 this_obj_conv.inner = untag_ptr(this_obj);
51582 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51584 PayeePubKey_free(this_obj_conv);
51587 int8_tArray __attribute__((export_name("TS_PayeePubKey_get_a"))) TS_PayeePubKey_get_a(uint64_t this_ptr) {
51588 LDKPayeePubKey this_ptr_conv;
51589 this_ptr_conv.inner = untag_ptr(this_ptr);
51590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51592 this_ptr_conv.is_owned = false;
51593 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
51594 memcpy(ret_arr->elems, PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
51598 void __attribute__((export_name("TS_PayeePubKey_set_a"))) TS_PayeePubKey_set_a(uint64_t this_ptr, int8_tArray val) {
51599 LDKPayeePubKey this_ptr_conv;
51600 this_ptr_conv.inner = untag_ptr(this_ptr);
51601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51603 this_ptr_conv.is_owned = false;
51604 LDKPublicKey val_ref;
51605 CHECK(val->arr_len == 33);
51606 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
51607 PayeePubKey_set_a(&this_ptr_conv, val_ref);
51610 uint64_t __attribute__((export_name("TS_PayeePubKey_new"))) TS_PayeePubKey_new(int8_tArray a_arg) {
51611 LDKPublicKey a_arg_ref;
51612 CHECK(a_arg->arr_len == 33);
51613 memcpy(a_arg_ref.compressed_form, a_arg->elems, 33); FREE(a_arg);
51614 LDKPayeePubKey ret_var = PayeePubKey_new(a_arg_ref);
51615 uint64_t ret_ref = 0;
51616 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51617 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51621 static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
51622 LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
51623 uint64_t ret_ref = 0;
51624 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51625 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51628 int64_t __attribute__((export_name("TS_PayeePubKey_clone_ptr"))) TS_PayeePubKey_clone_ptr(uint64_t arg) {
51629 LDKPayeePubKey arg_conv;
51630 arg_conv.inner = untag_ptr(arg);
51631 arg_conv.is_owned = ptr_is_owned(arg);
51632 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51633 arg_conv.is_owned = false;
51634 int64_t ret_conv = PayeePubKey_clone_ptr(&arg_conv);
51638 uint64_t __attribute__((export_name("TS_PayeePubKey_clone"))) TS_PayeePubKey_clone(uint64_t orig) {
51639 LDKPayeePubKey orig_conv;
51640 orig_conv.inner = untag_ptr(orig);
51641 orig_conv.is_owned = ptr_is_owned(orig);
51642 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51643 orig_conv.is_owned = false;
51644 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
51645 uint64_t ret_ref = 0;
51646 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51647 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51651 int64_t __attribute__((export_name("TS_PayeePubKey_hash"))) TS_PayeePubKey_hash(uint64_t o) {
51652 LDKPayeePubKey o_conv;
51653 o_conv.inner = untag_ptr(o);
51654 o_conv.is_owned = ptr_is_owned(o);
51655 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51656 o_conv.is_owned = false;
51657 int64_t ret_conv = PayeePubKey_hash(&o_conv);
51661 jboolean __attribute__((export_name("TS_PayeePubKey_eq"))) TS_PayeePubKey_eq(uint64_t a, uint64_t b) {
51662 LDKPayeePubKey a_conv;
51663 a_conv.inner = untag_ptr(a);
51664 a_conv.is_owned = ptr_is_owned(a);
51665 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51666 a_conv.is_owned = false;
51667 LDKPayeePubKey b_conv;
51668 b_conv.inner = untag_ptr(b);
51669 b_conv.is_owned = ptr_is_owned(b);
51670 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51671 b_conv.is_owned = false;
51672 jboolean ret_conv = PayeePubKey_eq(&a_conv, &b_conv);
51676 void __attribute__((export_name("TS_ExpiryTime_free"))) TS_ExpiryTime_free(uint64_t this_obj) {
51677 LDKExpiryTime this_obj_conv;
51678 this_obj_conv.inner = untag_ptr(this_obj);
51679 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51681 ExpiryTime_free(this_obj_conv);
51684 static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
51685 LDKExpiryTime ret_var = ExpiryTime_clone(arg);
51686 uint64_t ret_ref = 0;
51687 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51688 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51691 int64_t __attribute__((export_name("TS_ExpiryTime_clone_ptr"))) TS_ExpiryTime_clone_ptr(uint64_t arg) {
51692 LDKExpiryTime arg_conv;
51693 arg_conv.inner = untag_ptr(arg);
51694 arg_conv.is_owned = ptr_is_owned(arg);
51695 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51696 arg_conv.is_owned = false;
51697 int64_t ret_conv = ExpiryTime_clone_ptr(&arg_conv);
51701 uint64_t __attribute__((export_name("TS_ExpiryTime_clone"))) TS_ExpiryTime_clone(uint64_t orig) {
51702 LDKExpiryTime orig_conv;
51703 orig_conv.inner = untag_ptr(orig);
51704 orig_conv.is_owned = ptr_is_owned(orig);
51705 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51706 orig_conv.is_owned = false;
51707 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
51708 uint64_t ret_ref = 0;
51709 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51710 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51714 int64_t __attribute__((export_name("TS_ExpiryTime_hash"))) TS_ExpiryTime_hash(uint64_t o) {
51715 LDKExpiryTime o_conv;
51716 o_conv.inner = untag_ptr(o);
51717 o_conv.is_owned = ptr_is_owned(o);
51718 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51719 o_conv.is_owned = false;
51720 int64_t ret_conv = ExpiryTime_hash(&o_conv);
51724 jboolean __attribute__((export_name("TS_ExpiryTime_eq"))) TS_ExpiryTime_eq(uint64_t a, uint64_t b) {
51725 LDKExpiryTime a_conv;
51726 a_conv.inner = untag_ptr(a);
51727 a_conv.is_owned = ptr_is_owned(a);
51728 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51729 a_conv.is_owned = false;
51730 LDKExpiryTime b_conv;
51731 b_conv.inner = untag_ptr(b);
51732 b_conv.is_owned = ptr_is_owned(b);
51733 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51734 b_conv.is_owned = false;
51735 jboolean ret_conv = ExpiryTime_eq(&a_conv, &b_conv);
51739 void __attribute__((export_name("TS_MinFinalCltvExpiryDelta_free"))) TS_MinFinalCltvExpiryDelta_free(uint64_t this_obj) {
51740 LDKMinFinalCltvExpiryDelta this_obj_conv;
51741 this_obj_conv.inner = untag_ptr(this_obj);
51742 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51744 MinFinalCltvExpiryDelta_free(this_obj_conv);
51747 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_get_a"))) TS_MinFinalCltvExpiryDelta_get_a(uint64_t this_ptr) {
51748 LDKMinFinalCltvExpiryDelta this_ptr_conv;
51749 this_ptr_conv.inner = untag_ptr(this_ptr);
51750 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51752 this_ptr_conv.is_owned = false;
51753 int64_t ret_conv = MinFinalCltvExpiryDelta_get_a(&this_ptr_conv);
51757 void __attribute__((export_name("TS_MinFinalCltvExpiryDelta_set_a"))) TS_MinFinalCltvExpiryDelta_set_a(uint64_t this_ptr, int64_t val) {
51758 LDKMinFinalCltvExpiryDelta this_ptr_conv;
51759 this_ptr_conv.inner = untag_ptr(this_ptr);
51760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
51761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
51762 this_ptr_conv.is_owned = false;
51763 MinFinalCltvExpiryDelta_set_a(&this_ptr_conv, val);
51766 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_new"))) TS_MinFinalCltvExpiryDelta_new(int64_t a_arg) {
51767 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_new(a_arg);
51768 uint64_t ret_ref = 0;
51769 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51770 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51774 static inline uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg) {
51775 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_clone(arg);
51776 uint64_t ret_ref = 0;
51777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51781 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_clone_ptr"))) TS_MinFinalCltvExpiryDelta_clone_ptr(uint64_t arg) {
51782 LDKMinFinalCltvExpiryDelta arg_conv;
51783 arg_conv.inner = untag_ptr(arg);
51784 arg_conv.is_owned = ptr_is_owned(arg);
51785 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51786 arg_conv.is_owned = false;
51787 int64_t ret_conv = MinFinalCltvExpiryDelta_clone_ptr(&arg_conv);
51791 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_clone"))) TS_MinFinalCltvExpiryDelta_clone(uint64_t orig) {
51792 LDKMinFinalCltvExpiryDelta orig_conv;
51793 orig_conv.inner = untag_ptr(orig);
51794 orig_conv.is_owned = ptr_is_owned(orig);
51795 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51796 orig_conv.is_owned = false;
51797 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_clone(&orig_conv);
51798 uint64_t ret_ref = 0;
51799 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51800 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51804 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_hash"))) TS_MinFinalCltvExpiryDelta_hash(uint64_t o) {
51805 LDKMinFinalCltvExpiryDelta o_conv;
51806 o_conv.inner = untag_ptr(o);
51807 o_conv.is_owned = ptr_is_owned(o);
51808 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51809 o_conv.is_owned = false;
51810 int64_t ret_conv = MinFinalCltvExpiryDelta_hash(&o_conv);
51814 jboolean __attribute__((export_name("TS_MinFinalCltvExpiryDelta_eq"))) TS_MinFinalCltvExpiryDelta_eq(uint64_t a, uint64_t b) {
51815 LDKMinFinalCltvExpiryDelta a_conv;
51816 a_conv.inner = untag_ptr(a);
51817 a_conv.is_owned = ptr_is_owned(a);
51818 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51819 a_conv.is_owned = false;
51820 LDKMinFinalCltvExpiryDelta b_conv;
51821 b_conv.inner = untag_ptr(b);
51822 b_conv.is_owned = ptr_is_owned(b);
51823 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51824 b_conv.is_owned = false;
51825 jboolean ret_conv = MinFinalCltvExpiryDelta_eq(&a_conv, &b_conv);
51829 void __attribute__((export_name("TS_Fallback_free"))) TS_Fallback_free(uint64_t this_ptr) {
51830 if (!ptr_is_owned(this_ptr)) return;
51831 void* this_ptr_ptr = untag_ptr(this_ptr);
51832 CHECK_ACCESS(this_ptr_ptr);
51833 LDKFallback this_ptr_conv = *(LDKFallback*)(this_ptr_ptr);
51834 FREE(untag_ptr(this_ptr));
51835 Fallback_free(this_ptr_conv);
51838 static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
51839 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51840 *ret_copy = Fallback_clone(arg);
51841 uint64_t ret_ref = tag_ptr(ret_copy, true);
51844 int64_t __attribute__((export_name("TS_Fallback_clone_ptr"))) TS_Fallback_clone_ptr(uint64_t arg) {
51845 LDKFallback* arg_conv = (LDKFallback*)untag_ptr(arg);
51846 int64_t ret_conv = Fallback_clone_ptr(arg_conv);
51850 uint64_t __attribute__((export_name("TS_Fallback_clone"))) TS_Fallback_clone(uint64_t orig) {
51851 LDKFallback* orig_conv = (LDKFallback*)untag_ptr(orig);
51852 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51853 *ret_copy = Fallback_clone(orig_conv);
51854 uint64_t ret_ref = tag_ptr(ret_copy, true);
51858 uint64_t __attribute__((export_name("TS_Fallback_seg_wit_program"))) TS_Fallback_seg_wit_program(int8_t version, int8_tArray program) {
51860 LDKCVec_u8Z program_ref;
51861 program_ref.datalen = program->arr_len;
51862 program_ref.data = MALLOC(program_ref.datalen, "LDKCVec_u8Z Bytes");
51863 memcpy(program_ref.data, program->elems, program_ref.datalen); FREE(program);
51864 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51865 *ret_copy = Fallback_seg_wit_program((LDKWitnessVersion){ ._0 = version }, program_ref);
51866 uint64_t ret_ref = tag_ptr(ret_copy, true);
51870 uint64_t __attribute__((export_name("TS_Fallback_pub_key_hash"))) TS_Fallback_pub_key_hash(int8_tArray a) {
51871 LDKTwentyBytes a_ref;
51872 CHECK(a->arr_len == 20);
51873 memcpy(a_ref.data, a->elems, 20); FREE(a);
51874 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51875 *ret_copy = Fallback_pub_key_hash(a_ref);
51876 uint64_t ret_ref = tag_ptr(ret_copy, true);
51880 uint64_t __attribute__((export_name("TS_Fallback_script_hash"))) TS_Fallback_script_hash(int8_tArray a) {
51881 LDKTwentyBytes a_ref;
51882 CHECK(a->arr_len == 20);
51883 memcpy(a_ref.data, a->elems, 20); FREE(a);
51884 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
51885 *ret_copy = Fallback_script_hash(a_ref);
51886 uint64_t ret_ref = tag_ptr(ret_copy, true);
51890 int64_t __attribute__((export_name("TS_Fallback_hash"))) TS_Fallback_hash(uint64_t o) {
51891 LDKFallback* o_conv = (LDKFallback*)untag_ptr(o);
51892 int64_t ret_conv = Fallback_hash(o_conv);
51896 jboolean __attribute__((export_name("TS_Fallback_eq"))) TS_Fallback_eq(uint64_t a, uint64_t b) {
51897 LDKFallback* a_conv = (LDKFallback*)untag_ptr(a);
51898 LDKFallback* b_conv = (LDKFallback*)untag_ptr(b);
51899 jboolean ret_conv = Fallback_eq(a_conv, b_conv);
51903 void __attribute__((export_name("TS_InvoiceSignature_free"))) TS_InvoiceSignature_free(uint64_t this_obj) {
51904 LDKInvoiceSignature this_obj_conv;
51905 this_obj_conv.inner = untag_ptr(this_obj);
51906 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51907 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51908 InvoiceSignature_free(this_obj_conv);
51911 static inline uint64_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
51912 LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
51913 uint64_t ret_ref = 0;
51914 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51915 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51918 int64_t __attribute__((export_name("TS_InvoiceSignature_clone_ptr"))) TS_InvoiceSignature_clone_ptr(uint64_t arg) {
51919 LDKInvoiceSignature arg_conv;
51920 arg_conv.inner = untag_ptr(arg);
51921 arg_conv.is_owned = ptr_is_owned(arg);
51922 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51923 arg_conv.is_owned = false;
51924 int64_t ret_conv = InvoiceSignature_clone_ptr(&arg_conv);
51928 uint64_t __attribute__((export_name("TS_InvoiceSignature_clone"))) TS_InvoiceSignature_clone(uint64_t orig) {
51929 LDKInvoiceSignature orig_conv;
51930 orig_conv.inner = untag_ptr(orig);
51931 orig_conv.is_owned = ptr_is_owned(orig);
51932 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51933 orig_conv.is_owned = false;
51934 LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
51935 uint64_t ret_ref = 0;
51936 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51937 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51941 int64_t __attribute__((export_name("TS_InvoiceSignature_hash"))) TS_InvoiceSignature_hash(uint64_t o) {
51942 LDKInvoiceSignature o_conv;
51943 o_conv.inner = untag_ptr(o);
51944 o_conv.is_owned = ptr_is_owned(o);
51945 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
51946 o_conv.is_owned = false;
51947 int64_t ret_conv = InvoiceSignature_hash(&o_conv);
51951 jboolean __attribute__((export_name("TS_InvoiceSignature_eq"))) TS_InvoiceSignature_eq(uint64_t a, uint64_t b) {
51952 LDKInvoiceSignature a_conv;
51953 a_conv.inner = untag_ptr(a);
51954 a_conv.is_owned = ptr_is_owned(a);
51955 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
51956 a_conv.is_owned = false;
51957 LDKInvoiceSignature b_conv;
51958 b_conv.inner = untag_ptr(b);
51959 b_conv.is_owned = ptr_is_owned(b);
51960 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
51961 b_conv.is_owned = false;
51962 jboolean ret_conv = InvoiceSignature_eq(&a_conv, &b_conv);
51966 void __attribute__((export_name("TS_PrivateRoute_free"))) TS_PrivateRoute_free(uint64_t this_obj) {
51967 LDKPrivateRoute this_obj_conv;
51968 this_obj_conv.inner = untag_ptr(this_obj);
51969 this_obj_conv.is_owned = ptr_is_owned(this_obj);
51970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
51971 PrivateRoute_free(this_obj_conv);
51974 static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
51975 LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
51976 uint64_t ret_ref = 0;
51977 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
51978 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
51981 int64_t __attribute__((export_name("TS_PrivateRoute_clone_ptr"))) TS_PrivateRoute_clone_ptr(uint64_t arg) {
51982 LDKPrivateRoute arg_conv;
51983 arg_conv.inner = untag_ptr(arg);
51984 arg_conv.is_owned = ptr_is_owned(arg);
51985 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
51986 arg_conv.is_owned = false;
51987 int64_t ret_conv = PrivateRoute_clone_ptr(&arg_conv);
51991 uint64_t __attribute__((export_name("TS_PrivateRoute_clone"))) TS_PrivateRoute_clone(uint64_t orig) {
51992 LDKPrivateRoute orig_conv;
51993 orig_conv.inner = untag_ptr(orig);
51994 orig_conv.is_owned = ptr_is_owned(orig);
51995 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
51996 orig_conv.is_owned = false;
51997 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
51998 uint64_t ret_ref = 0;
51999 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52000 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52004 int64_t __attribute__((export_name("TS_PrivateRoute_hash"))) TS_PrivateRoute_hash(uint64_t o) {
52005 LDKPrivateRoute o_conv;
52006 o_conv.inner = untag_ptr(o);
52007 o_conv.is_owned = ptr_is_owned(o);
52008 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
52009 o_conv.is_owned = false;
52010 int64_t ret_conv = PrivateRoute_hash(&o_conv);
52014 jboolean __attribute__((export_name("TS_PrivateRoute_eq"))) TS_PrivateRoute_eq(uint64_t a, uint64_t b) {
52015 LDKPrivateRoute a_conv;
52016 a_conv.inner = untag_ptr(a);
52017 a_conv.is_owned = ptr_is_owned(a);
52018 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
52019 a_conv.is_owned = false;
52020 LDKPrivateRoute b_conv;
52021 b_conv.inner = untag_ptr(b);
52022 b_conv.is_owned = ptr_is_owned(b);
52023 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
52024 b_conv.is_owned = false;
52025 jboolean ret_conv = PrivateRoute_eq(&a_conv, &b_conv);
52029 uint64_t __attribute__((export_name("TS_SignedRawInvoice_into_parts"))) TS_SignedRawInvoice_into_parts(uint64_t this_arg) {
52030 LDKSignedRawInvoice this_arg_conv;
52031 this_arg_conv.inner = untag_ptr(this_arg);
52032 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52033 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52034 this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
52035 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
52036 *ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
52037 return tag_ptr(ret_conv, true);
52040 uint64_t __attribute__((export_name("TS_SignedRawInvoice_raw_invoice"))) TS_SignedRawInvoice_raw_invoice(uint64_t this_arg) {
52041 LDKSignedRawInvoice this_arg_conv;
52042 this_arg_conv.inner = untag_ptr(this_arg);
52043 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52044 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52045 this_arg_conv.is_owned = false;
52046 LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
52047 uint64_t ret_ref = 0;
52048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52049 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52053 int8_tArray __attribute__((export_name("TS_SignedRawInvoice_signable_hash"))) TS_SignedRawInvoice_signable_hash(uint64_t this_arg) {
52054 LDKSignedRawInvoice this_arg_conv;
52055 this_arg_conv.inner = untag_ptr(this_arg);
52056 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52057 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52058 this_arg_conv.is_owned = false;
52059 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52060 memcpy(ret_arr->elems, *SignedRawInvoice_signable_hash(&this_arg_conv), 32);
52064 uint64_t __attribute__((export_name("TS_SignedRawInvoice_signature"))) TS_SignedRawInvoice_signature(uint64_t this_arg) {
52065 LDKSignedRawInvoice this_arg_conv;
52066 this_arg_conv.inner = untag_ptr(this_arg);
52067 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52068 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52069 this_arg_conv.is_owned = false;
52070 LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
52071 uint64_t ret_ref = 0;
52072 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52073 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52077 uint64_t __attribute__((export_name("TS_SignedRawInvoice_recover_payee_pub_key"))) TS_SignedRawInvoice_recover_payee_pub_key(uint64_t this_arg) {
52078 LDKSignedRawInvoice this_arg_conv;
52079 this_arg_conv.inner = untag_ptr(this_arg);
52080 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52081 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52082 this_arg_conv.is_owned = false;
52083 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
52084 *ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
52085 return tag_ptr(ret_conv, true);
52088 jboolean __attribute__((export_name("TS_SignedRawInvoice_check_signature"))) TS_SignedRawInvoice_check_signature(uint64_t this_arg) {
52089 LDKSignedRawInvoice this_arg_conv;
52090 this_arg_conv.inner = untag_ptr(this_arg);
52091 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52092 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52093 this_arg_conv.is_owned = false;
52094 jboolean ret_conv = SignedRawInvoice_check_signature(&this_arg_conv);
52098 int8_tArray __attribute__((export_name("TS_RawInvoice_signable_hash"))) TS_RawInvoice_signable_hash(uint64_t this_arg) {
52099 LDKRawInvoice this_arg_conv;
52100 this_arg_conv.inner = untag_ptr(this_arg);
52101 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52102 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52103 this_arg_conv.is_owned = false;
52104 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52105 memcpy(ret_arr->elems, RawInvoice_signable_hash(&this_arg_conv).data, 32);
52109 uint64_t __attribute__((export_name("TS_RawInvoice_payment_hash"))) TS_RawInvoice_payment_hash(uint64_t this_arg) {
52110 LDKRawInvoice this_arg_conv;
52111 this_arg_conv.inner = untag_ptr(this_arg);
52112 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52113 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52114 this_arg_conv.is_owned = false;
52115 LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
52116 uint64_t ret_ref = 0;
52117 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52118 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52122 uint64_t __attribute__((export_name("TS_RawInvoice_description"))) TS_RawInvoice_description(uint64_t this_arg) {
52123 LDKRawInvoice this_arg_conv;
52124 this_arg_conv.inner = untag_ptr(this_arg);
52125 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52127 this_arg_conv.is_owned = false;
52128 LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
52129 uint64_t ret_ref = 0;
52130 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52131 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52135 uint64_t __attribute__((export_name("TS_RawInvoice_payee_pub_key"))) TS_RawInvoice_payee_pub_key(uint64_t this_arg) {
52136 LDKRawInvoice this_arg_conv;
52137 this_arg_conv.inner = untag_ptr(this_arg);
52138 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52140 this_arg_conv.is_owned = false;
52141 LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
52142 uint64_t ret_ref = 0;
52143 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52144 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52148 uint64_t __attribute__((export_name("TS_RawInvoice_description_hash"))) TS_RawInvoice_description_hash(uint64_t this_arg) {
52149 LDKRawInvoice this_arg_conv;
52150 this_arg_conv.inner = untag_ptr(this_arg);
52151 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52152 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52153 this_arg_conv.is_owned = false;
52154 LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
52155 uint64_t ret_ref = 0;
52156 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52157 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52161 uint64_t __attribute__((export_name("TS_RawInvoice_expiry_time"))) TS_RawInvoice_expiry_time(uint64_t this_arg) {
52162 LDKRawInvoice this_arg_conv;
52163 this_arg_conv.inner = untag_ptr(this_arg);
52164 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52166 this_arg_conv.is_owned = false;
52167 LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
52168 uint64_t ret_ref = 0;
52169 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52170 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52174 uint64_t __attribute__((export_name("TS_RawInvoice_min_final_cltv_expiry_delta"))) TS_RawInvoice_min_final_cltv_expiry_delta(uint64_t this_arg) {
52175 LDKRawInvoice this_arg_conv;
52176 this_arg_conv.inner = untag_ptr(this_arg);
52177 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52179 this_arg_conv.is_owned = false;
52180 LDKMinFinalCltvExpiryDelta ret_var = RawInvoice_min_final_cltv_expiry_delta(&this_arg_conv);
52181 uint64_t ret_ref = 0;
52182 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52183 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52187 int8_tArray __attribute__((export_name("TS_RawInvoice_payment_secret"))) TS_RawInvoice_payment_secret(uint64_t this_arg) {
52188 LDKRawInvoice this_arg_conv;
52189 this_arg_conv.inner = untag_ptr(this_arg);
52190 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52191 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52192 this_arg_conv.is_owned = false;
52193 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52194 memcpy(ret_arr->elems, RawInvoice_payment_secret(&this_arg_conv).data, 32);
52198 uint64_t __attribute__((export_name("TS_RawInvoice_payment_metadata"))) TS_RawInvoice_payment_metadata(uint64_t this_arg) {
52199 LDKRawInvoice this_arg_conv;
52200 this_arg_conv.inner = untag_ptr(this_arg);
52201 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52202 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52203 this_arg_conv.is_owned = false;
52204 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
52205 *ret_copy = RawInvoice_payment_metadata(&this_arg_conv);
52206 uint64_t ret_ref = tag_ptr(ret_copy, true);
52210 uint64_t __attribute__((export_name("TS_RawInvoice_features"))) TS_RawInvoice_features(uint64_t this_arg) {
52211 LDKRawInvoice this_arg_conv;
52212 this_arg_conv.inner = untag_ptr(this_arg);
52213 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52214 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52215 this_arg_conv.is_owned = false;
52216 LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
52217 uint64_t ret_ref = 0;
52218 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52219 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52223 uint64_tArray __attribute__((export_name("TS_RawInvoice_private_routes"))) TS_RawInvoice_private_routes(uint64_t this_arg) {
52224 LDKRawInvoice this_arg_conv;
52225 this_arg_conv.inner = untag_ptr(this_arg);
52226 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52228 this_arg_conv.is_owned = false;
52229 LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
52230 uint64_tArray ret_arr = NULL;
52231 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52232 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52233 for (size_t o = 0; o < ret_var.datalen; o++) {
52234 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
52235 uint64_t ret_conv_14_ref = 0;
52236 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
52237 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
52238 ret_arr_ptr[o] = ret_conv_14_ref;
52241 FREE(ret_var.data);
52245 uint64_t __attribute__((export_name("TS_RawInvoice_amount_pico_btc"))) TS_RawInvoice_amount_pico_btc(uint64_t this_arg) {
52246 LDKRawInvoice this_arg_conv;
52247 this_arg_conv.inner = untag_ptr(this_arg);
52248 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52250 this_arg_conv.is_owned = false;
52251 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
52252 *ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
52253 uint64_t ret_ref = tag_ptr(ret_copy, true);
52257 uint32_t __attribute__((export_name("TS_RawInvoice_currency"))) TS_RawInvoice_currency(uint64_t this_arg) {
52258 LDKRawInvoice this_arg_conv;
52259 this_arg_conv.inner = untag_ptr(this_arg);
52260 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52262 this_arg_conv.is_owned = false;
52263 uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
52267 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_unix_timestamp"))) TS_PositiveTimestamp_from_unix_timestamp(int64_t unix_seconds) {
52268 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
52269 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
52270 return tag_ptr(ret_conv, true);
52273 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_duration_since_epoch"))) TS_PositiveTimestamp_from_duration_since_epoch(int64_t duration) {
52274 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
52275 *ret_conv = PositiveTimestamp_from_duration_since_epoch(duration);
52276 return tag_ptr(ret_conv, true);
52279 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_unix_timestamp"))) TS_PositiveTimestamp_as_unix_timestamp(uint64_t this_arg) {
52280 LDKPositiveTimestamp this_arg_conv;
52281 this_arg_conv.inner = untag_ptr(this_arg);
52282 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52283 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52284 this_arg_conv.is_owned = false;
52285 int64_t ret_conv = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
52289 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_duration_since_epoch"))) TS_PositiveTimestamp_as_duration_since_epoch(uint64_t this_arg) {
52290 LDKPositiveTimestamp this_arg_conv;
52291 this_arg_conv.inner = untag_ptr(this_arg);
52292 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52294 this_arg_conv.is_owned = false;
52295 int64_t ret_conv = PositiveTimestamp_as_duration_since_epoch(&this_arg_conv);
52299 int8_tArray __attribute__((export_name("TS_Invoice_signable_hash"))) TS_Invoice_signable_hash(uint64_t this_arg) {
52300 LDKInvoice this_arg_conv;
52301 this_arg_conv.inner = untag_ptr(this_arg);
52302 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52303 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52304 this_arg_conv.is_owned = false;
52305 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52306 memcpy(ret_arr->elems, Invoice_signable_hash(&this_arg_conv).data, 32);
52310 uint64_t __attribute__((export_name("TS_Invoice_into_signed_raw"))) TS_Invoice_into_signed_raw(uint64_t this_arg) {
52311 LDKInvoice this_arg_conv;
52312 this_arg_conv.inner = untag_ptr(this_arg);
52313 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52314 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52315 this_arg_conv = Invoice_clone(&this_arg_conv);
52316 LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
52317 uint64_t ret_ref = 0;
52318 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52319 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52323 uint64_t __attribute__((export_name("TS_Invoice_check_signature"))) TS_Invoice_check_signature(uint64_t this_arg) {
52324 LDKInvoice this_arg_conv;
52325 this_arg_conv.inner = untag_ptr(this_arg);
52326 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52327 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52328 this_arg_conv.is_owned = false;
52329 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
52330 *ret_conv = Invoice_check_signature(&this_arg_conv);
52331 return tag_ptr(ret_conv, true);
52334 uint64_t __attribute__((export_name("TS_Invoice_from_signed"))) TS_Invoice_from_signed(uint64_t signed_invoice) {
52335 LDKSignedRawInvoice signed_invoice_conv;
52336 signed_invoice_conv.inner = untag_ptr(signed_invoice);
52337 signed_invoice_conv.is_owned = ptr_is_owned(signed_invoice);
52338 CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
52339 signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
52340 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
52341 *ret_conv = Invoice_from_signed(signed_invoice_conv);
52342 return tag_ptr(ret_conv, true);
52345 int64_t __attribute__((export_name("TS_Invoice_duration_since_epoch"))) TS_Invoice_duration_since_epoch(uint64_t this_arg) {
52346 LDKInvoice this_arg_conv;
52347 this_arg_conv.inner = untag_ptr(this_arg);
52348 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52349 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52350 this_arg_conv.is_owned = false;
52351 int64_t ret_conv = Invoice_duration_since_epoch(&this_arg_conv);
52355 int8_tArray __attribute__((export_name("TS_Invoice_payment_hash"))) TS_Invoice_payment_hash(uint64_t this_arg) {
52356 LDKInvoice this_arg_conv;
52357 this_arg_conv.inner = untag_ptr(this_arg);
52358 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52359 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52360 this_arg_conv.is_owned = false;
52361 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52362 memcpy(ret_arr->elems, *Invoice_payment_hash(&this_arg_conv), 32);
52366 int8_tArray __attribute__((export_name("TS_Invoice_payee_pub_key"))) TS_Invoice_payee_pub_key(uint64_t this_arg) {
52367 LDKInvoice this_arg_conv;
52368 this_arg_conv.inner = untag_ptr(this_arg);
52369 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52371 this_arg_conv.is_owned = false;
52372 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
52373 memcpy(ret_arr->elems, Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
52377 int8_tArray __attribute__((export_name("TS_Invoice_payment_secret"))) TS_Invoice_payment_secret(uint64_t this_arg) {
52378 LDKInvoice this_arg_conv;
52379 this_arg_conv.inner = untag_ptr(this_arg);
52380 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52381 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52382 this_arg_conv.is_owned = false;
52383 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
52384 memcpy(ret_arr->elems, *Invoice_payment_secret(&this_arg_conv), 32);
52388 uint64_t __attribute__((export_name("TS_Invoice_payment_metadata"))) TS_Invoice_payment_metadata(uint64_t this_arg) {
52389 LDKInvoice this_arg_conv;
52390 this_arg_conv.inner = untag_ptr(this_arg);
52391 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52393 this_arg_conv.is_owned = false;
52394 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
52395 *ret_copy = Invoice_payment_metadata(&this_arg_conv);
52396 uint64_t ret_ref = tag_ptr(ret_copy, true);
52400 uint64_t __attribute__((export_name("TS_Invoice_features"))) TS_Invoice_features(uint64_t this_arg) {
52401 LDKInvoice this_arg_conv;
52402 this_arg_conv.inner = untag_ptr(this_arg);
52403 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52404 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52405 this_arg_conv.is_owned = false;
52406 LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
52407 uint64_t ret_ref = 0;
52408 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52409 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52413 int8_tArray __attribute__((export_name("TS_Invoice_recover_payee_pub_key"))) TS_Invoice_recover_payee_pub_key(uint64_t this_arg) {
52414 LDKInvoice this_arg_conv;
52415 this_arg_conv.inner = untag_ptr(this_arg);
52416 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52418 this_arg_conv.is_owned = false;
52419 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
52420 memcpy(ret_arr->elems, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
52424 uint64_t __attribute__((export_name("TS_Invoice_expires_at"))) TS_Invoice_expires_at(uint64_t this_arg) {
52425 LDKInvoice this_arg_conv;
52426 this_arg_conv.inner = untag_ptr(this_arg);
52427 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52429 this_arg_conv.is_owned = false;
52430 LDKCOption_DurationZ *ret_copy = MALLOC(sizeof(LDKCOption_DurationZ), "LDKCOption_DurationZ");
52431 *ret_copy = Invoice_expires_at(&this_arg_conv);
52432 uint64_t ret_ref = tag_ptr(ret_copy, true);
52436 int64_t __attribute__((export_name("TS_Invoice_expiry_time"))) TS_Invoice_expiry_time(uint64_t this_arg) {
52437 LDKInvoice this_arg_conv;
52438 this_arg_conv.inner = untag_ptr(this_arg);
52439 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52440 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52441 this_arg_conv.is_owned = false;
52442 int64_t ret_conv = Invoice_expiry_time(&this_arg_conv);
52446 int64_t __attribute__((export_name("TS_Invoice_expiration_remaining_from_epoch"))) TS_Invoice_expiration_remaining_from_epoch(uint64_t this_arg, int64_t time) {
52447 LDKInvoice this_arg_conv;
52448 this_arg_conv.inner = untag_ptr(this_arg);
52449 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52450 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52451 this_arg_conv.is_owned = false;
52452 int64_t ret_conv = Invoice_expiration_remaining_from_epoch(&this_arg_conv, time);
52456 jboolean __attribute__((export_name("TS_Invoice_would_expire"))) TS_Invoice_would_expire(uint64_t this_arg, int64_t at_time) {
52457 LDKInvoice this_arg_conv;
52458 this_arg_conv.inner = untag_ptr(this_arg);
52459 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52460 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52461 this_arg_conv.is_owned = false;
52462 jboolean ret_conv = Invoice_would_expire(&this_arg_conv, at_time);
52466 int64_t __attribute__((export_name("TS_Invoice_min_final_cltv_expiry_delta"))) TS_Invoice_min_final_cltv_expiry_delta(uint64_t this_arg) {
52467 LDKInvoice this_arg_conv;
52468 this_arg_conv.inner = untag_ptr(this_arg);
52469 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52471 this_arg_conv.is_owned = false;
52472 int64_t ret_conv = Invoice_min_final_cltv_expiry_delta(&this_arg_conv);
52476 ptrArray __attribute__((export_name("TS_Invoice_fallback_addresses"))) TS_Invoice_fallback_addresses(uint64_t this_arg) {
52477 LDKInvoice this_arg_conv;
52478 this_arg_conv.inner = untag_ptr(this_arg);
52479 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52481 this_arg_conv.is_owned = false;
52482 LDKCVec_AddressZ ret_var = Invoice_fallback_addresses(&this_arg_conv);
52483 ptrArray ret_arr = NULL;
52484 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
52485 jstring *ret_arr_ptr = (jstring*)(((uint8_t*)ret_arr) + 8);
52486 for (size_t i = 0; i < ret_var.datalen; i++) {
52487 LDKStr ret_conv_8_str = ret_var.data[i];
52488 jstring ret_conv_8_conv = str_ref_to_ts(ret_conv_8_str.chars, ret_conv_8_str.len);
52489 Str_free(ret_conv_8_str);
52490 ret_arr_ptr[i] = ret_conv_8_conv;
52493 FREE(ret_var.data);
52497 uint64_tArray __attribute__((export_name("TS_Invoice_private_routes"))) TS_Invoice_private_routes(uint64_t this_arg) {
52498 LDKInvoice this_arg_conv;
52499 this_arg_conv.inner = untag_ptr(this_arg);
52500 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52501 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52502 this_arg_conv.is_owned = false;
52503 LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
52504 uint64_tArray ret_arr = NULL;
52505 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52506 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52507 for (size_t o = 0; o < ret_var.datalen; o++) {
52508 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
52509 uint64_t ret_conv_14_ref = 0;
52510 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
52511 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
52512 ret_arr_ptr[o] = ret_conv_14_ref;
52515 FREE(ret_var.data);
52519 uint64_tArray __attribute__((export_name("TS_Invoice_route_hints"))) TS_Invoice_route_hints(uint64_t this_arg) {
52520 LDKInvoice this_arg_conv;
52521 this_arg_conv.inner = untag_ptr(this_arg);
52522 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52523 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52524 this_arg_conv.is_owned = false;
52525 LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
52526 uint64_tArray ret_arr = NULL;
52527 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52528 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52529 for (size_t l = 0; l < ret_var.datalen; l++) {
52530 LDKRouteHint ret_conv_11_var = ret_var.data[l];
52531 uint64_t ret_conv_11_ref = 0;
52532 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
52533 ret_conv_11_ref = tag_ptr(ret_conv_11_var.inner, ret_conv_11_var.is_owned);
52534 ret_arr_ptr[l] = ret_conv_11_ref;
52537 FREE(ret_var.data);
52541 uint32_t __attribute__((export_name("TS_Invoice_currency"))) TS_Invoice_currency(uint64_t this_arg) {
52542 LDKInvoice this_arg_conv;
52543 this_arg_conv.inner = untag_ptr(this_arg);
52544 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52545 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52546 this_arg_conv.is_owned = false;
52547 uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
52551 uint64_t __attribute__((export_name("TS_Invoice_amount_milli_satoshis"))) TS_Invoice_amount_milli_satoshis(uint64_t this_arg) {
52552 LDKInvoice this_arg_conv;
52553 this_arg_conv.inner = untag_ptr(this_arg);
52554 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52556 this_arg_conv.is_owned = false;
52557 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
52558 *ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
52559 uint64_t ret_ref = tag_ptr(ret_copy, true);
52563 uint64_t __attribute__((export_name("TS_Description_new"))) TS_Description_new(jstring description) {
52564 LDKStr description_conv = str_ref_to_owned_c(description);
52565 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
52566 *ret_conv = Description_new(description_conv);
52567 return tag_ptr(ret_conv, true);
52570 jstring __attribute__((export_name("TS_Description_into_inner"))) TS_Description_into_inner(uint64_t this_arg) {
52571 LDKDescription this_arg_conv;
52572 this_arg_conv.inner = untag_ptr(this_arg);
52573 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52575 this_arg_conv = Description_clone(&this_arg_conv);
52576 LDKStr ret_str = Description_into_inner(this_arg_conv);
52577 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52582 uint64_t __attribute__((export_name("TS_ExpiryTime_from_seconds"))) TS_ExpiryTime_from_seconds(int64_t seconds) {
52583 LDKExpiryTime ret_var = ExpiryTime_from_seconds(seconds);
52584 uint64_t ret_ref = 0;
52585 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52586 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52590 uint64_t __attribute__((export_name("TS_ExpiryTime_from_duration"))) TS_ExpiryTime_from_duration(int64_t duration) {
52591 LDKExpiryTime ret_var = ExpiryTime_from_duration(duration);
52592 uint64_t ret_ref = 0;
52593 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52594 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52598 int64_t __attribute__((export_name("TS_ExpiryTime_as_seconds"))) TS_ExpiryTime_as_seconds(uint64_t this_arg) {
52599 LDKExpiryTime this_arg_conv;
52600 this_arg_conv.inner = untag_ptr(this_arg);
52601 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52603 this_arg_conv.is_owned = false;
52604 int64_t ret_conv = ExpiryTime_as_seconds(&this_arg_conv);
52608 int64_t __attribute__((export_name("TS_ExpiryTime_as_duration"))) TS_ExpiryTime_as_duration(uint64_t this_arg) {
52609 LDKExpiryTime this_arg_conv;
52610 this_arg_conv.inner = untag_ptr(this_arg);
52611 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52613 this_arg_conv.is_owned = false;
52614 int64_t ret_conv = ExpiryTime_as_duration(&this_arg_conv);
52618 uint64_t __attribute__((export_name("TS_PrivateRoute_new"))) TS_PrivateRoute_new(uint64_t hops) {
52619 LDKRouteHint hops_conv;
52620 hops_conv.inner = untag_ptr(hops);
52621 hops_conv.is_owned = ptr_is_owned(hops);
52622 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
52623 hops_conv = RouteHint_clone(&hops_conv);
52624 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
52625 *ret_conv = PrivateRoute_new(hops_conv);
52626 return tag_ptr(ret_conv, true);
52629 uint64_t __attribute__((export_name("TS_PrivateRoute_into_inner"))) TS_PrivateRoute_into_inner(uint64_t this_arg) {
52630 LDKPrivateRoute this_arg_conv;
52631 this_arg_conv.inner = untag_ptr(this_arg);
52632 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52633 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52634 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
52635 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
52636 uint64_t ret_ref = 0;
52637 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52638 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52642 uint32_t __attribute__((export_name("TS_CreationError_clone"))) TS_CreationError_clone(uint64_t orig) {
52643 LDKCreationError* orig_conv = (LDKCreationError*)untag_ptr(orig);
52644 uint32_t ret_conv = LDKCreationError_to_js(CreationError_clone(orig_conv));
52648 uint32_t __attribute__((export_name("TS_CreationError_description_too_long"))) TS_CreationError_description_too_long() {
52649 uint32_t ret_conv = LDKCreationError_to_js(CreationError_description_too_long());
52653 uint32_t __attribute__((export_name("TS_CreationError_route_too_long"))) TS_CreationError_route_too_long() {
52654 uint32_t ret_conv = LDKCreationError_to_js(CreationError_route_too_long());
52658 uint32_t __attribute__((export_name("TS_CreationError_timestamp_out_of_bounds"))) TS_CreationError_timestamp_out_of_bounds() {
52659 uint32_t ret_conv = LDKCreationError_to_js(CreationError_timestamp_out_of_bounds());
52663 uint32_t __attribute__((export_name("TS_CreationError_invalid_amount"))) TS_CreationError_invalid_amount() {
52664 uint32_t ret_conv = LDKCreationError_to_js(CreationError_invalid_amount());
52668 uint32_t __attribute__((export_name("TS_CreationError_missing_route_hints"))) TS_CreationError_missing_route_hints() {
52669 uint32_t ret_conv = LDKCreationError_to_js(CreationError_missing_route_hints());
52673 uint32_t __attribute__((export_name("TS_CreationError_min_final_cltv_expiry_delta_too_short"))) TS_CreationError_min_final_cltv_expiry_delta_too_short() {
52674 uint32_t ret_conv = LDKCreationError_to_js(CreationError_min_final_cltv_expiry_delta_too_short());
52678 jboolean __attribute__((export_name("TS_CreationError_eq"))) TS_CreationError_eq(uint64_t a, uint64_t b) {
52679 LDKCreationError* a_conv = (LDKCreationError*)untag_ptr(a);
52680 LDKCreationError* b_conv = (LDKCreationError*)untag_ptr(b);
52681 jboolean ret_conv = CreationError_eq(a_conv, b_conv);
52685 jstring __attribute__((export_name("TS_CreationError_to_str"))) TS_CreationError_to_str(uint64_t o) {
52686 LDKCreationError* o_conv = (LDKCreationError*)untag_ptr(o);
52687 LDKStr ret_str = CreationError_to_str(o_conv);
52688 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52693 uint32_t __attribute__((export_name("TS_SemanticError_clone"))) TS_SemanticError_clone(uint64_t orig) {
52694 LDKSemanticError* orig_conv = (LDKSemanticError*)untag_ptr(orig);
52695 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_clone(orig_conv));
52699 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_hash"))) TS_SemanticError_no_payment_hash() {
52700 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_hash());
52704 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_hashes"))) TS_SemanticError_multiple_payment_hashes() {
52705 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_hashes());
52709 uint32_t __attribute__((export_name("TS_SemanticError_no_description"))) TS_SemanticError_no_description() {
52710 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_description());
52714 uint32_t __attribute__((export_name("TS_SemanticError_multiple_descriptions"))) TS_SemanticError_multiple_descriptions() {
52715 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_descriptions());
52719 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_secret"))) TS_SemanticError_no_payment_secret() {
52720 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_secret());
52724 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_secrets"))) TS_SemanticError_multiple_payment_secrets() {
52725 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_secrets());
52729 uint32_t __attribute__((export_name("TS_SemanticError_invalid_features"))) TS_SemanticError_invalid_features() {
52730 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_features());
52734 uint32_t __attribute__((export_name("TS_SemanticError_invalid_recovery_id"))) TS_SemanticError_invalid_recovery_id() {
52735 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_recovery_id());
52739 uint32_t __attribute__((export_name("TS_SemanticError_invalid_signature"))) TS_SemanticError_invalid_signature() {
52740 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_signature());
52744 uint32_t __attribute__((export_name("TS_SemanticError_imprecise_amount"))) TS_SemanticError_imprecise_amount() {
52745 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_imprecise_amount());
52749 jboolean __attribute__((export_name("TS_SemanticError_eq"))) TS_SemanticError_eq(uint64_t a, uint64_t b) {
52750 LDKSemanticError* a_conv = (LDKSemanticError*)untag_ptr(a);
52751 LDKSemanticError* b_conv = (LDKSemanticError*)untag_ptr(b);
52752 jboolean ret_conv = SemanticError_eq(a_conv, b_conv);
52756 jstring __attribute__((export_name("TS_SemanticError_to_str"))) TS_SemanticError_to_str(uint64_t o) {
52757 LDKSemanticError* o_conv = (LDKSemanticError*)untag_ptr(o);
52758 LDKStr ret_str = SemanticError_to_str(o_conv);
52759 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52764 void __attribute__((export_name("TS_SignOrCreationError_free"))) TS_SignOrCreationError_free(uint64_t this_ptr) {
52765 if (!ptr_is_owned(this_ptr)) return;
52766 void* this_ptr_ptr = untag_ptr(this_ptr);
52767 CHECK_ACCESS(this_ptr_ptr);
52768 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(this_ptr_ptr);
52769 FREE(untag_ptr(this_ptr));
52770 SignOrCreationError_free(this_ptr_conv);
52773 static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
52774 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52775 *ret_copy = SignOrCreationError_clone(arg);
52776 uint64_t ret_ref = tag_ptr(ret_copy, true);
52779 int64_t __attribute__((export_name("TS_SignOrCreationError_clone_ptr"))) TS_SignOrCreationError_clone_ptr(uint64_t arg) {
52780 LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)untag_ptr(arg);
52781 int64_t ret_conv = SignOrCreationError_clone_ptr(arg_conv);
52785 uint64_t __attribute__((export_name("TS_SignOrCreationError_clone"))) TS_SignOrCreationError_clone(uint64_t orig) {
52786 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)untag_ptr(orig);
52787 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52788 *ret_copy = SignOrCreationError_clone(orig_conv);
52789 uint64_t ret_ref = tag_ptr(ret_copy, true);
52793 uint64_t __attribute__((export_name("TS_SignOrCreationError_sign_error"))) TS_SignOrCreationError_sign_error() {
52794 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52795 *ret_copy = SignOrCreationError_sign_error();
52796 uint64_t ret_ref = tag_ptr(ret_copy, true);
52800 uint64_t __attribute__((export_name("TS_SignOrCreationError_creation_error"))) TS_SignOrCreationError_creation_error(uint32_t a) {
52801 LDKCreationError a_conv = LDKCreationError_from_js(a);
52802 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
52803 *ret_copy = SignOrCreationError_creation_error(a_conv);
52804 uint64_t ret_ref = tag_ptr(ret_copy, true);
52808 jboolean __attribute__((export_name("TS_SignOrCreationError_eq"))) TS_SignOrCreationError_eq(uint64_t a, uint64_t b) {
52809 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)untag_ptr(a);
52810 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)untag_ptr(b);
52811 jboolean ret_conv = SignOrCreationError_eq(a_conv, b_conv);
52815 jstring __attribute__((export_name("TS_SignOrCreationError_to_str"))) TS_SignOrCreationError_to_str(uint64_t o) {
52816 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)untag_ptr(o);
52817 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
52818 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
52823 uint64_t __attribute__((export_name("TS_pay_invoice"))) TS_pay_invoice(uint64_t invoice, uint64_t retry_strategy, uint64_t channelmanager) {
52824 LDKInvoice invoice_conv;
52825 invoice_conv.inner = untag_ptr(invoice);
52826 invoice_conv.is_owned = ptr_is_owned(invoice);
52827 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52828 invoice_conv.is_owned = false;
52829 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52830 CHECK_ACCESS(retry_strategy_ptr);
52831 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52832 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52833 LDKChannelManager channelmanager_conv;
52834 channelmanager_conv.inner = untag_ptr(channelmanager);
52835 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52836 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52837 channelmanager_conv.is_owned = false;
52838 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
52839 *ret_conv = pay_invoice(&invoice_conv, retry_strategy_conv, &channelmanager_conv);
52840 return tag_ptr(ret_conv, true);
52843 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) {
52844 LDKInvoice invoice_conv;
52845 invoice_conv.inner = untag_ptr(invoice);
52846 invoice_conv.is_owned = ptr_is_owned(invoice);
52847 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52848 invoice_conv.is_owned = false;
52849 LDKThirtyTwoBytes payment_id_ref;
52850 CHECK(payment_id->arr_len == 32);
52851 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
52852 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52853 CHECK_ACCESS(retry_strategy_ptr);
52854 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52855 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52856 LDKChannelManager channelmanager_conv;
52857 channelmanager_conv.inner = untag_ptr(channelmanager);
52858 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52859 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52860 channelmanager_conv.is_owned = false;
52861 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
52862 *ret_conv = pay_invoice_with_id(&invoice_conv, payment_id_ref, retry_strategy_conv, &channelmanager_conv);
52863 return tag_ptr(ret_conv, true);
52866 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) {
52867 LDKInvoice invoice_conv;
52868 invoice_conv.inner = untag_ptr(invoice);
52869 invoice_conv.is_owned = ptr_is_owned(invoice);
52870 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52871 invoice_conv.is_owned = false;
52872 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52873 CHECK_ACCESS(retry_strategy_ptr);
52874 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52875 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52876 LDKChannelManager channelmanager_conv;
52877 channelmanager_conv.inner = untag_ptr(channelmanager);
52878 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52879 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52880 channelmanager_conv.is_owned = false;
52881 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
52882 *ret_conv = pay_zero_value_invoice(&invoice_conv, amount_msats, retry_strategy_conv, &channelmanager_conv);
52883 return tag_ptr(ret_conv, true);
52886 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) {
52887 LDKInvoice invoice_conv;
52888 invoice_conv.inner = untag_ptr(invoice);
52889 invoice_conv.is_owned = ptr_is_owned(invoice);
52890 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
52891 invoice_conv.is_owned = false;
52892 LDKThirtyTwoBytes payment_id_ref;
52893 CHECK(payment_id->arr_len == 32);
52894 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
52895 void* retry_strategy_ptr = untag_ptr(retry_strategy);
52896 CHECK_ACCESS(retry_strategy_ptr);
52897 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
52898 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
52899 LDKChannelManager channelmanager_conv;
52900 channelmanager_conv.inner = untag_ptr(channelmanager);
52901 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
52902 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
52903 channelmanager_conv.is_owned = false;
52904 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
52905 *ret_conv = pay_zero_value_invoice_with_id(&invoice_conv, amount_msats, payment_id_ref, retry_strategy_conv, &channelmanager_conv);
52906 return tag_ptr(ret_conv, true);
52909 void __attribute__((export_name("TS_PaymentError_free"))) TS_PaymentError_free(uint64_t this_ptr) {
52910 if (!ptr_is_owned(this_ptr)) return;
52911 void* this_ptr_ptr = untag_ptr(this_ptr);
52912 CHECK_ACCESS(this_ptr_ptr);
52913 LDKPaymentError this_ptr_conv = *(LDKPaymentError*)(this_ptr_ptr);
52914 FREE(untag_ptr(this_ptr));
52915 PaymentError_free(this_ptr_conv);
52918 static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
52919 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52920 *ret_copy = PaymentError_clone(arg);
52921 uint64_t ret_ref = tag_ptr(ret_copy, true);
52924 int64_t __attribute__((export_name("TS_PaymentError_clone_ptr"))) TS_PaymentError_clone_ptr(uint64_t arg) {
52925 LDKPaymentError* arg_conv = (LDKPaymentError*)untag_ptr(arg);
52926 int64_t ret_conv = PaymentError_clone_ptr(arg_conv);
52930 uint64_t __attribute__((export_name("TS_PaymentError_clone"))) TS_PaymentError_clone(uint64_t orig) {
52931 LDKPaymentError* orig_conv = (LDKPaymentError*)untag_ptr(orig);
52932 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52933 *ret_copy = PaymentError_clone(orig_conv);
52934 uint64_t ret_ref = tag_ptr(ret_copy, true);
52938 uint64_t __attribute__((export_name("TS_PaymentError_invoice"))) TS_PaymentError_invoice(jstring a) {
52939 LDKStr a_conv = str_ref_to_owned_c(a);
52940 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52941 *ret_copy = PaymentError_invoice(a_conv);
52942 uint64_t ret_ref = tag_ptr(ret_copy, true);
52946 uint64_t __attribute__((export_name("TS_PaymentError_sending"))) TS_PaymentError_sending(uint32_t a) {
52947 LDKRetryableSendFailure a_conv = LDKRetryableSendFailure_from_js(a);
52948 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
52949 *ret_copy = PaymentError_sending(a_conv);
52950 uint64_t ret_ref = tag_ptr(ret_copy, true);
52954 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) {
52955 void* amt_msat_ptr = untag_ptr(amt_msat);
52956 CHECK_ACCESS(amt_msat_ptr);
52957 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
52958 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
52959 LDKThirtyTwoBytes payment_hash_ref;
52960 CHECK(payment_hash->arr_len == 32);
52961 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
52962 LDKStr description_conv = str_ref_to_owned_c(description);
52963 LDKCVec_PhantomRouteHintsZ phantom_route_hints_constr;
52964 phantom_route_hints_constr.datalen = phantom_route_hints->arr_len;
52965 if (phantom_route_hints_constr.datalen > 0)
52966 phantom_route_hints_constr.data = MALLOC(phantom_route_hints_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
52968 phantom_route_hints_constr.data = NULL;
52969 uint64_t* phantom_route_hints_vals = phantom_route_hints->elems;
52970 for (size_t t = 0; t < phantom_route_hints_constr.datalen; t++) {
52971 uint64_t phantom_route_hints_conv_19 = phantom_route_hints_vals[t];
52972 LDKPhantomRouteHints phantom_route_hints_conv_19_conv;
52973 phantom_route_hints_conv_19_conv.inner = untag_ptr(phantom_route_hints_conv_19);
52974 phantom_route_hints_conv_19_conv.is_owned = ptr_is_owned(phantom_route_hints_conv_19);
52975 CHECK_INNER_FIELD_ACCESS_OR_NULL(phantom_route_hints_conv_19_conv);
52976 phantom_route_hints_conv_19_conv = PhantomRouteHints_clone(&phantom_route_hints_conv_19_conv);
52977 phantom_route_hints_constr.data[t] = phantom_route_hints_conv_19_conv;
52979 FREE(phantom_route_hints);
52980 void* entropy_source_ptr = untag_ptr(entropy_source);
52981 CHECK_ACCESS(entropy_source_ptr);
52982 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
52983 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
52984 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
52985 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
52987 void* node_signer_ptr = untag_ptr(node_signer);
52988 CHECK_ACCESS(node_signer_ptr);
52989 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
52990 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
52991 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
52992 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
52994 void* logger_ptr = untag_ptr(logger);
52995 CHECK_ACCESS(logger_ptr);
52996 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
52997 if (logger_conv.free == LDKLogger_JCalls_free) {
52998 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
52999 LDKLogger_JCalls_cloned(&logger_conv);
53001 LDKCurrency network_conv = LDKCurrency_from_js(network);
53002 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53003 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53004 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53005 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53006 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53007 *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);
53008 return tag_ptr(ret_conv, true);
53011 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) {
53012 void* amt_msat_ptr = untag_ptr(amt_msat);
53013 CHECK_ACCESS(amt_msat_ptr);
53014 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53015 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53016 LDKThirtyTwoBytes payment_hash_ref;
53017 CHECK(payment_hash->arr_len == 32);
53018 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
53019 LDKSha256 description_hash_conv;
53020 description_hash_conv.inner = untag_ptr(description_hash);
53021 description_hash_conv.is_owned = ptr_is_owned(description_hash);
53022 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
53023 description_hash_conv = Sha256_clone(&description_hash_conv);
53024 LDKCVec_PhantomRouteHintsZ phantom_route_hints_constr;
53025 phantom_route_hints_constr.datalen = phantom_route_hints->arr_len;
53026 if (phantom_route_hints_constr.datalen > 0)
53027 phantom_route_hints_constr.data = MALLOC(phantom_route_hints_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
53029 phantom_route_hints_constr.data = NULL;
53030 uint64_t* phantom_route_hints_vals = phantom_route_hints->elems;
53031 for (size_t t = 0; t < phantom_route_hints_constr.datalen; t++) {
53032 uint64_t phantom_route_hints_conv_19 = phantom_route_hints_vals[t];
53033 LDKPhantomRouteHints phantom_route_hints_conv_19_conv;
53034 phantom_route_hints_conv_19_conv.inner = untag_ptr(phantom_route_hints_conv_19);
53035 phantom_route_hints_conv_19_conv.is_owned = ptr_is_owned(phantom_route_hints_conv_19);
53036 CHECK_INNER_FIELD_ACCESS_OR_NULL(phantom_route_hints_conv_19_conv);
53037 phantom_route_hints_conv_19_conv = PhantomRouteHints_clone(&phantom_route_hints_conv_19_conv);
53038 phantom_route_hints_constr.data[t] = phantom_route_hints_conv_19_conv;
53040 FREE(phantom_route_hints);
53041 void* entropy_source_ptr = untag_ptr(entropy_source);
53042 CHECK_ACCESS(entropy_source_ptr);
53043 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
53044 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
53045 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53046 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
53048 void* node_signer_ptr = untag_ptr(node_signer);
53049 CHECK_ACCESS(node_signer_ptr);
53050 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53051 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53052 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53053 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53055 void* logger_ptr = untag_ptr(logger);
53056 CHECK_ACCESS(logger_ptr);
53057 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53058 if (logger_conv.free == LDKLogger_JCalls_free) {
53059 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53060 LDKLogger_JCalls_cloned(&logger_conv);
53062 LDKCurrency network_conv = LDKCurrency_from_js(network);
53063 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53064 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53065 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53066 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53067 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53068 *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);
53069 return tag_ptr(ret_conv, true);
53072 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) {
53073 LDKChannelManager channelmanager_conv;
53074 channelmanager_conv.inner = untag_ptr(channelmanager);
53075 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
53076 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
53077 channelmanager_conv.is_owned = false;
53078 void* node_signer_ptr = untag_ptr(node_signer);
53079 CHECK_ACCESS(node_signer_ptr);
53080 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53081 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53082 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53083 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53085 void* logger_ptr = untag_ptr(logger);
53086 CHECK_ACCESS(logger_ptr);
53087 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53088 if (logger_conv.free == LDKLogger_JCalls_free) {
53089 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53090 LDKLogger_JCalls_cloned(&logger_conv);
53092 LDKCurrency network_conv = LDKCurrency_from_js(network);
53093 void* amt_msat_ptr = untag_ptr(amt_msat);
53094 CHECK_ACCESS(amt_msat_ptr);
53095 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53096 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53097 LDKSha256 description_hash_conv;
53098 description_hash_conv.inner = untag_ptr(description_hash);
53099 description_hash_conv.is_owned = ptr_is_owned(description_hash);
53100 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
53101 description_hash_conv = Sha256_clone(&description_hash_conv);
53102 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53103 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53104 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53105 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53106 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53107 *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);
53108 return tag_ptr(ret_conv, true);
53111 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) {
53112 LDKChannelManager channelmanager_conv;
53113 channelmanager_conv.inner = untag_ptr(channelmanager);
53114 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
53115 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
53116 channelmanager_conv.is_owned = false;
53117 void* node_signer_ptr = untag_ptr(node_signer);
53118 CHECK_ACCESS(node_signer_ptr);
53119 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53120 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53121 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53122 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53124 void* logger_ptr = untag_ptr(logger);
53125 CHECK_ACCESS(logger_ptr);
53126 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53127 if (logger_conv.free == LDKLogger_JCalls_free) {
53128 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53129 LDKLogger_JCalls_cloned(&logger_conv);
53131 LDKCurrency network_conv = LDKCurrency_from_js(network);
53132 void* amt_msat_ptr = untag_ptr(amt_msat);
53133 CHECK_ACCESS(amt_msat_ptr);
53134 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53135 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53136 LDKStr description_conv = str_ref_to_owned_c(description);
53137 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53138 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53139 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53140 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53141 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53142 *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);
53143 return tag_ptr(ret_conv, true);
53146 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) {
53147 LDKChannelManager channelmanager_conv;
53148 channelmanager_conv.inner = untag_ptr(channelmanager);
53149 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
53150 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
53151 channelmanager_conv.is_owned = false;
53152 void* node_signer_ptr = untag_ptr(node_signer);
53153 CHECK_ACCESS(node_signer_ptr);
53154 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
53155 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
53156 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53157 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
53159 void* logger_ptr = untag_ptr(logger);
53160 CHECK_ACCESS(logger_ptr);
53161 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
53162 if (logger_conv.free == LDKLogger_JCalls_free) {
53163 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
53164 LDKLogger_JCalls_cloned(&logger_conv);
53166 LDKCurrency network_conv = LDKCurrency_from_js(network);
53167 void* amt_msat_ptr = untag_ptr(amt_msat);
53168 CHECK_ACCESS(amt_msat_ptr);
53169 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
53170 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
53171 LDKStr description_conv = str_ref_to_owned_c(description);
53172 LDKThirtyTwoBytes payment_hash_ref;
53173 CHECK(payment_hash->arr_len == 32);
53174 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
53175 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
53176 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
53177 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
53178 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
53179 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
53180 *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);
53181 return tag_ptr(ret_conv, true);
53184 uint64_t __attribute__((export_name("TS_SiPrefix_from_str"))) TS_SiPrefix_from_str(jstring s) {
53185 LDKStr s_conv = str_ref_to_owned_c(s);
53186 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
53187 *ret_conv = SiPrefix_from_str(s_conv);
53188 return tag_ptr(ret_conv, true);
53191 uint64_t __attribute__((export_name("TS_Invoice_from_str"))) TS_Invoice_from_str(jstring s) {
53192 LDKStr s_conv = str_ref_to_owned_c(s);
53193 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
53194 *ret_conv = Invoice_from_str(s_conv);
53195 return tag_ptr(ret_conv, true);
53198 uint64_t __attribute__((export_name("TS_SignedRawInvoice_from_str"))) TS_SignedRawInvoice_from_str(jstring s) {
53199 LDKStr s_conv = str_ref_to_owned_c(s);
53200 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
53201 *ret_conv = SignedRawInvoice_from_str(s_conv);
53202 return tag_ptr(ret_conv, true);
53205 jstring __attribute__((export_name("TS_ParseError_to_str"))) TS_ParseError_to_str(uint64_t o) {
53206 LDKParseError* o_conv = (LDKParseError*)untag_ptr(o);
53207 LDKStr ret_str = ParseError_to_str(o_conv);
53208 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53213 jstring __attribute__((export_name("TS_ParseOrSemanticError_to_str"))) TS_ParseOrSemanticError_to_str(uint64_t o) {
53214 LDKParseOrSemanticError* o_conv = (LDKParseOrSemanticError*)untag_ptr(o);
53215 LDKStr ret_str = ParseOrSemanticError_to_str(o_conv);
53216 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53221 jstring __attribute__((export_name("TS_Invoice_to_str"))) TS_Invoice_to_str(uint64_t o) {
53223 o_conv.inner = untag_ptr(o);
53224 o_conv.is_owned = ptr_is_owned(o);
53225 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
53226 o_conv.is_owned = false;
53227 LDKStr ret_str = Invoice_to_str(&o_conv);
53228 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53233 jstring __attribute__((export_name("TS_SignedRawInvoice_to_str"))) TS_SignedRawInvoice_to_str(uint64_t o) {
53234 LDKSignedRawInvoice o_conv;
53235 o_conv.inner = untag_ptr(o);
53236 o_conv.is_owned = ptr_is_owned(o);
53237 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
53238 o_conv.is_owned = false;
53239 LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
53240 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53245 jstring __attribute__((export_name("TS_Currency_to_str"))) TS_Currency_to_str(uint64_t o) {
53246 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
53247 LDKStr ret_str = Currency_to_str(o_conv);
53248 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
53253 jstring __attribute__((export_name("TS_SiPrefix_to_str"))) TS_SiPrefix_to_str(uint64_t o) {
53254 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
53255 LDKStr ret_str = SiPrefix_to_str(o_conv);
53256 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);